C# IReadOnlyList.Contains方法代码示例

        public static void CloseOpenWindows(IReadOnlyList<string> skipProcessList = null, bool forceClose = false)
        {
            if (skipProcessList == null)
                skipProcessList = new string[0];

            var list = GetOpenWindows();
            list = list.Where(p => !skipProcessList.Contains(p.ProcessName.ToLower()));

            CloseWindows(list, forceClose);
        }

        public IReadOnlyList<IUniverseDao> GetOrCreate(IReadOnlyList<string> universeNames)
        {
            var existing = Context.Universes.Where(u => universeNames.Contains(u.Name)).ToImmutableList();

            var missingNames = universeNames.Except(existing.Select(u => u.Name));
            var allUniverses = new List<UniverseDao>(existing);

            foreach (var name in missingNames)
            {
                var universe = new UniverseDao { Name = name };
                Context.Universes.Add(universe);
                allUniverses.Add(universe);
            }

            Context.SaveChanges();
            return allUniverses;
        }

        private void ExportCollada_NodeSub(XmlWriter xml, IReadOnlyList<string> boneNames, Kn5Node node) {
            xml.WriteStartElement("node");
            xml.WriteAttributeStringSafe("id", node.Name);
            xml.WriteAttributeStringSafe("sid", node.Name);
            xml.WriteAttributeStringSafe("name", node.Name);

            xml.WriteAttributeString("layer", node.Active ? "Visible" : "Hidden");
            xml.WriteAttributeString("type", node.NodeClass == Kn5NodeClass.Base && boneNames.Contains(node.Name) ? "JOINT" : "NODE");

            if (node.Children?.FirstOrDefault()?.NodeClass != Kn5NodeClass.SkinnedMesh) {
                xml.WriteElement("matrix",
                        "sid", "transform",
                        node.NodeClass == Kn5NodeClass.Base ? XmlWriterExtension.MatrixToCollada(node.Transform) : "1 0 0 0 0 1 0 0 0 0 1 0 0 0 0 0");
            }

            if (IsMultiMaterial(node) && node.Children != null) {
                xml.WriteStartElement("instance_geometry");
                xml.WriteAttributeStringSafe("url", $"#{node.Name}-mesh");
                ExportCollada_NodeSub_BindMaterial(xml, node.Children.Select(x => x.MaterialId).ToArray());
                xml.WriteEndElement();
            } else {
                ExportCollada_NodeSub_Inner(xml, boneNames, node);
            }

            xml.WriteEndElement(); // node
        }

 private static IEnumerable<KspPartLinkProperty> FilterOutPartLinks (IReadOnlyList<KspPartLinkProperty> links, IReadOnlyList<KspPartObject> parts) =>
     links.Where (link => !parts.Contains (link.Part));

        private async Task<IEnumerable<TenantResource>> FindTenantsByName(IReadOnlyList<string> tenantNames)
        {
            if (!tenantNames.Any())
            {
                return Enumerable.Empty<TenantResource>();
            }

            if (tenantNames.Contains("*"))
            {
                return await repository.Tenants.FindAll().ConfigureAwait(false);
            }

            var tenantsByName = await repository.Tenants.FindByNames(tenantNames).ConfigureAwait(false);
            var missing = tenantsByName == null || !tenantsByName.Any()
                ? tenantNames.ToArray()
                : tenantNames.Except(tenantsByName.Select(e => e.Name), StringComparer.OrdinalIgnoreCase).ToArray();

            var tenantsById = await repository.Tenants.Get(missing).ConfigureAwait(false);

            missing = tenantsById == null || !tenantsById.Any()
                ? missing
                : missing.Except(tenantsById.Select(e => e.Id), StringComparer.OrdinalIgnoreCase).ToArray();

            if (missing.Any())
            {
                throw new ArgumentException($"Could not find the {"tenant" + (missing.Length == 1 ? "" : "s")} {string.Join(", ", missing)} on the Octopus server.");
            }

            var allTenants = Enumerable.Empty<TenantResource>();
            if (tenantsById != null)
            {
                allTenants = allTenants.Concat(tenantsById);
            }
            if (tenantsByName != null)
            {
                allTenants = allTenants.Concat(tenantsByName);
            }

            return allTenants;
        }

	    private static void ExcludePaths(Project proj, IReadOnlyList<string> excludedPaths)
	    {
	        var toRemove = proj.Items.Where(item => excludedPaths.Contains(item.UnevaluatedInclude)).ToList();
	        proj.RemoveItems(toRemove);
        }