C# IEnumerable.?.Select方法代码示例

        public ICollection<string> GetEnsuredBlogKeys(IEnumerable<string> blogKeys)
        {
            var blogKeyList = blogKeys?.Select(x => new BlogKey(x));

            var ensuredBlogKeys = this.GetEnsuredBlogKeys(blogKeyList);
            return ensuredBlogKeys;
        }

		static public IEnumerable<MeasurementBound1DIntAtTime> MappedDrift(
			IEnumerable<MeasurementBound1DIntAtTime> Source,
			Int64 DriftTimeFixed,
			Int64 DriftNano) =>
			Source
			?.Select(BoundPreDrift =>
			BoundPreDrift.BoundOffset((Int64)(((BoundPreDrift.Time - DriftTimeFixed) * BoundPreDrift.Bound * DriftNano) / 1e+9)));

        public Superhero CreateSuperhero(string superheroName, string secretIdentity, string cityName, IEnumerable<string> powerNames)
        {
            if (string.IsNullOrEmpty(superheroName) ||
                superheroName.Length < MinSuperheroNameLength ||
            superheroName.Length > MaxSuperherNameLength)
            {
                throw new ArgumentException("Invalid supehero name");
            }

            var superhero = new Superhero
            {
                SuperheroName = superheroName,
                SecretIdentity = secretIdentity,
                City = this.LoadOrCreateCity(cityName),
                Powers = powerNames?.Select(this.LoadOrCreatePower)
                    .ToList()
            };

            using (this.unitOfWork)
            {
                this.superheroes.Add(superhero);
                this.unitOfWork.Commit();
            }

            return superhero;
        }

 public GenericDataValueProvider(System.Reflection.MemberInfo member, IValueProvider inner, IEnumerable<string> sensitiveProperties)
 {
     if (member == null) throw new ArgumentNullException("member");
     if (inner == null) throw new ArgumentNullException("inner");
     Member = member;
     Inner = inner;
     SensitiveProperties = sensitiveProperties?.Select(p => p.ToLowerInvariant());
 }

        public static UserDto CreateUserDto(this User user, IEnumerable<Login> logins)
        {
            var userDto = user.CreateUserDto();

            userDto.Logins = logins?.Select(CreateLoginDto).ToArray() ?? new LoginDto[0];

            return userDto;
        }

        /// <summary>
        /// Initialisiert eine neue Instanz der <see cref="Pkcs7EncryptionHandler"/> Klasse.
        /// </summary>
        /// <param name="senderCertificate">Das X509-Zertifikat des Absenders (PKCS#12)</param>
        /// <param name="receiverCertificate">Das X509-Zertifikat des Empfängers</param>
        /// <param name="oldSenderCertificates">Die abgelaufenen X509-Zertifikate des Absenders</param>
        public Pkcs7EncryptionHandler(X509Certificate2 senderCertificate, X509Certificate2 receiverCertificate, IEnumerable<X509Certificate2> oldSenderCertificates = null)
        {
#if NET45
            _encryptionHandler = new NativePkcs7EncryptionHandler(senderCertificate, receiverCertificate, oldSenderCertificates);
#else
            var senderCert = new Pkcs12Store(new MemoryStream(senderCertificate.Export(X509ContentType.Pkcs12)), new char[0]);
            var receiverCert = new Org.BouncyCastle.X509.X509CertificateParser().ReadCertificate(receiverCertificate.RawData);
            var oldSenderCerts = oldSenderCertificates?.Select(cert => new Pkcs12Store(new MemoryStream(cert.Export(X509ContentType.Pkcs12)), new char[0]));
            _encryptionHandler = new BouncyCastlePkcs7EncryptionHandler(senderCert, receiverCert, oldSenderCerts);
#endif
        }

		/// <summary>
		/// Возвращает сообщения с указанными идентификаторами, либо если 
		/// идентификаторы не указаны, возвращает текущие выделенные сообщения.
		/// </summary>
		public static IEnumerable<IForumMessageInfo> GetMessages(
			IServiceProvider serviceProvider,
			IEnumerable<int> messageIds)
		{
			return
				messageIds
					?.Select(msgId => (IForumMessageInfo)DatabaseManager.GetMessageWithForum(serviceProvider, msgId))
						?? serviceProvider
					.GetRequiredService<IActiveMessagesService>()
					.ActiveMessages;
		}

 /// <summary>
 /// Adds a package.
 /// </summary>
 /// <param name="packageId">The package identifier.</param>
 /// <param name="packageSources">The package sources.</param>
 /// <param name="versionRange">The version range.</param>
 /// <param name="getLatest">If set to <c>true</c>, the latest version of the package will always be downloaded.</param>
 /// <param name="allowPrereleaseVersions">If set to <c>true</c>, allow prerelease versions.</param>
 /// <param name="allowUnlisted">If set to <c>true</c>, allow unlisted versions.</param>
 /// <param name="exclusive">If set to <c>true</c>, only use the package sources defined for this package.</param>
 public void AddPackage(string packageId, IEnumerable<string> packageSources = null, string versionRange = null,
     bool getLatest = false, bool allowPrereleaseVersions = false, bool allowUnlisted = false, bool exclusive = false)
 {
     if (_packages.ContainsKey(packageId))
     {
         throw new ArgumentException($"A package with the ID {packageId} has already been added");
     }
     _packages.Add(packageId, new Package(_currentFramework, packageId,
         packageSources?.Select(_sourceRepositories.CreateRepository).ToList(),
         versionRange, getLatest, allowPrereleaseVersions, allowUnlisted, exclusive));
 }

        private IEnumerable<IContextItem> BuildContext(IEnumerable<KeyValuePair<string, string>> parameters, IConfiguration config)
        {
            // build any context from the query string and http request
            var parameterContext = parameters?.Select(p => p.ToContextItem()).ToArray() ?? new IContextItem[] { };

            // build any context from the config files
            var configContext = config?.ContextItems?.ToArray() ?? new IContextItem[] { };

            // build any context from the plugins - they get to see any context generated so far
            var pluginContext  = this.pluginContextProvider.Contribute(parameterContext.Union(configContext)) ?? new IContextItem[] { };

            // squish it all together.  add parameters last so they can overide stuff generated by the plugins
            return configContext.Union(pluginContext).Union(parameterContext).ToArray();
        }

 public IEnumerable<PersonViewModel> MapPeopleList(IEnumerable<PersonDto> peopleDtoList)
 {
     return peopleDtoList?.Select(MapPerson).ToList();
 }

 private void PostCreate(HostService hostService, IEnumerable<FileAndType> files)
 {
     using (new LoggerPhaseScope("ReportModelLoadInfo", true))
     {
         if (!hostService.ShouldTraceIncrementalInfo)
         {
             return;
         }
         var allFiles = files?.Select(f => f.File) ?? new string[0];
         var loadedFiles = hostService.Models.Select(m => m.FileAndType.File);
         IncrementalContext.ReportModelLoadInfo(hostService, allFiles.Except(loadedFiles), null);
         IncrementalContext.ReportModelLoadInfo(hostService, loadedFiles, BuildPhase.PreBuildBuild);
     }
 }

 public static List<SelectListItem> ToSelectListItems(this IEnumerable<PluginFeatureManifest> PluginFeatureDefinitions, IEnumerable<PluginFeatureManifest> SelectedItems)
 {
     return PluginFeatureDefinitions.ToSelectListItems(SelectedItems?.Select(i => i.Id), false, null);
 }

		static public IEnumerable<MemoryStruct.ITreeViewEntry> SetTreeEntrySuitingSelectedPath(
			this IEnumerable<MemoryStruct.ITreeViewEntry> SetTreeEntryRoot,
			IEnumerable<string> SelectedPathListNodeLabel)
		{
			if (null == SetTreeEntryRoot || null == SelectedPathListNodeLabel)
			{
				return null;
			}

			var PathListNodeLabelLessFormatting =
				SelectedPathListNodeLabel?.Select(Label => Label?.RemoveXmlTag()?.Trim())?.ToArray();

			var PathListNodeLabelNext =
				PathListNodeLabelLessFormatting?.FirstOrDefault();

			if (null == PathListNodeLabelNext)
			{
				return null;
			}

			var SetTreeEntryRootSuitingPathNodeNext =
				SetTreeEntryRoot
				?.Where(TreeEntry => (TreeEntry?.Text?.RemoveXmlTag()?.Trim()).EqualsIgnoreCase(PathListNodeLabelNext))
				?.ToArray();

			if (null == SetTreeEntryRootSuitingPathNodeNext)
			{
				return null;
			}

			if (PathListNodeLabelLessFormatting.Length < 2)
			{
				return SetTreeEntryRootSuitingPathNodeNext;
			}

			return
				SetTreeEntryRootSuitingPathNodeNext
				.Select((LinxTreeEntryPasend) =>
					SetTreeEntrySuitingSelectedPath(
						LinxTreeEntryPasend.Child,
						SelectedPathListNodeLabel.Skip(1)))
				?.Where((Kandidaat) => null != Kandidaat)
				?.ConcatNullable();
		}

 public IEnumerable<BorrowViewModel> MapBorrowTransactionList(IEnumerable<BorrowDto> borrowDtoList)
 {
     return borrowDtoList?.Select(MapBorrowViewModel).ToList();
 }

        public Task EditMember(string serverId, string userId, bool? mute = null, bool? deaf = null, IEnumerable<object> roles = null)
		{
			CheckReady();
			if (serverId == null) throw new NullReferenceException(nameof(serverId));
			if (userId == null) throw new NullReferenceException(nameof(userId));

			IEnumerable<string> newRoles = roles?.Select(x =>
			{
				if (x is string)
					return x as string;
				else if (x is Role)
					return (x as Role).Id;
				else
					throw new ArgumentException("Roles must be a collection of string or Role.", nameof(roles));
			});

			return _api.EditMember(serverId, userId, mute: mute, deaf: deaf, roles: newRoles);
		}