C# List.Select方法代码示例

        private ElementCollection CreateElementGroup(string xPath, List<Element> list)
        {
            var names = new Dictionary<string, int>();
            foreach (var name in list.Select(el => el.Name))
            {
                if (names.ContainsKey(name))
                    names[name]++;
                else
                    names.Add(name, 1);
            }
            string mostRepeatedName = names.Keys.OrderBy(name => names[name]).First();

            int minX = list.Select(el => el.Location.X).Min();
            int minY = list.Select(el => el.Location.Y).Min();
            int maxX = list.Select(el => el.Location.X + el.Size.Width).Max();
            int maxY = list.Select(el => el.Location.Y + el.Size.Height).Max();

            var firstLocation = new Point(minX, minY);
            var combinedArea = new Size(maxX - minX, maxY - minY);
            return new ElementCollection()
            {
                Name = mostRepeatedName + "Group",
                LocatorType = "xpath",
                Locator = xPath,
                Location = firstLocation,
                Size = combinedArea
            };
        }

        public WbImageData(
            List<WbVmUtils.PlotPoint<Color>> plotPoints,
            List<WbVmUtils.PlotRectangle<Color>> filledRects,
            List<WbVmUtils.PlotRectangle<Color>> openRects,
            List<WbVmUtils.PlotLine<Color>> plotLines, 
            double width, 
            double height)
        {
            Height = height;
            Width = width;
            PlotPoints = plotPoints;
            FilledRectangles = filledRects;
            OpenRectangles = openRects;
            PlotLines = plotLines;

            BoundingRect = RectExt.NegInfRect
                .BoundingRect(plotLines.Select(pl => pl.X1))
                .BoundingRect(plotLines.Select(pl => pl.X2))
                .BoundingRect(plotLines.Select(pl => pl.Y1))
                .BoundingRect(plotLines.Select(pl => pl.Y2))
                .BoundingRect(filledRects.Select(pl => pl.X))
                .BoundingRect(filledRects.Select(pl => pl.X + pl.Width))
                .BoundingRect(filledRects.Select(pl => pl.Y))
                .BoundingRect(filledRects.Select(pl => pl.Y + pl.Height))
                .BoundingRect(openRects.Select(pl => pl.X))
                .BoundingRect(openRects.Select(pl => pl.X + pl.Width))
                .BoundingRect(openRects.Select(pl => pl.Y))
                .BoundingRect(openRects.Select(pl => pl.Y + pl.Height))
                .BoundingRect(plotPoints.Select(pl => pl.X))
                .BoundingRect(plotPoints.Select(pl => pl.Y));
        }

        private Delegate CreateActionDelegate(MethodInfo method)
        {
            List<ParameterExpression> parameters = new List<ParameterExpression>();
            foreach (ParameterInfo parameterInfo in method.GetParameters())
            {
                parameters.Add(Expression.Parameter(parameterInfo.ParameterType, parameterInfo.Name));
            }

            LambdaExpression lambda;

            if (method.IsStatic)
            {
                lambda = Expression.Lambda(
                    GetActionType(parameters.Select(p => p.Type).ToArray()),
                    Expression.Call(method, parameters.Cast<Expression>().ToArray()),
                    parameters.ToArray());
            }
            else
            {
                Type bindingType = method.DeclaringType;
                Expression<Func<object>> getInstanceExpression =
                    () => ScenarioContext.Current.GetBindingInstance(bindingType);

                lambda = Expression.Lambda(
                    GetActionType(parameters.Select(p => p.Type).ToArray()),
                    Expression.Call(
                        Expression.Convert(getInstanceExpression.Body, bindingType),
                        method,
                        parameters.Cast<Expression>().ToArray()),
                    parameters.ToArray());
            }


            return lambda.Compile();
        }

 private static IEnumerable<string> GetUsedPaths(List<Customer> customers)
 {
     IEnumerable<string> usedPaths = customers.Select(cust => cust.PhotoPath);
     usedPaths = usedPaths.Concat(customers.Select(cust => cust.ProofOfIdPath));
     usedPaths = usedPaths.Concat(customers.Select(cust => cust.Address.ProofOfAddressPath));
     return usedPaths;
 }

        private List<DpsPerCharacter> FillEmptyDataPoints(List<DpsPerCharacter> list)
        {
            var allCharacters = list.Select(m => m.character).Distinct().OrderBy(m => m).ToList();
            var allIntervals = list.Select(m => m.interval).Distinct().OrderBy(m => m).ToList();

            // Fill in missing intervals
            var lastInterval = allIntervals.FirstOrDefault();
            foreach (var interval in allIntervals.OrderBy(m => m))
            {
                int diff = interval - lastInterval;
                if (diff > 1)
                {
                    for (int i = 1; i < diff; i++)
                    {
                        foreach (var character in allCharacters)
                        {
                            list.Add(new DpsPerCharacter { character = character, damage = 0, interval = lastInterval + i });
                        }
                    }
                }

                foreach (var character in allCharacters)
                {
                    if (list.Any(m => m.character == character && m.interval == interval) == false)
                    {
                        list.Add(new DpsPerCharacter { character = character, interval = interval, damage = 0 });
                    }
                }

                lastInterval = interval;
            }

            return list;
        }

        [Fact] // CodePlex 583
        public void RemoveDuplicateTphColumns_removes_multiple_batches_of_duplicate_columns_from_same_table()
        {
            var removed = new List<EdmMember>();
            var mockTableType = CreateMockType("Lancre");
            mockTableType.Setup(m => m.RemoveMember(It.IsAny<EdmMember>())).Callback<EdmMember>(removed.Add);

            var columns = CreateColumns(
                mockTableType,
                "Nanny", "Ogg", "Nanny", "Nanny", "Granny", "Magrat", "Weatherwax", "Weatherwax", "Magrat", "Garlik", "Tiffany", "Tiffany");

            var mappings = CreateMappings(
                columns,
                "Nanny1", "Ogg", "Nanny2", "Nanny2", "Granny", "Magrat1", "Weatherwax", "Weatherwax", "Magrat2", "Garlik", "Tiffany",
                "Tiffany");

            new TphColumnFixer(mappings).RemoveDuplicateTphColumns();

            Assert.Equal(5, removed.Count);
            Assert.Equal(2, removed.Select(m => m.Name).Count(n => n == "Nanny"));
            Assert.Equal(1, removed.Select(m => m.Name).Count(n => n == "Weatherwax"));
            Assert.Equal(1, removed.Select(m => m.Name).Count(n => n == "Magrat"));
            Assert.Equal(1, removed.Select(m => m.Name).Count(n => n == "Tiffany"));

            AssertDuplicatesRemoved(mappings, "Nanny");
            AssertDuplicatesRemoved(mappings, "Weatherwax");
            AssertDuplicatesRemoved(mappings, "Magrat");
            AssertDuplicatesRemoved(mappings, "Tiffany");
        }

 public static IEnumerable<RestrictionModel> Sanitize(this IEnumerable<RestrictionModel> input)
 {
     var patterns = new List<PatternRestrictionModel>();
     foreach (var item in input)
     {
         var pattern = item as PatternRestrictionModel;
         if (pattern != null)
             patterns.Add(pattern);
         else
             yield return item;
     }
     if (patterns.Count == 1)
     {
         yield return patterns[0];
     }
     else if (patterns.Count > 1)
     {
         var config = patterns.Select(x => x.Configuration).First();
         var pattern = string.Join("|", patterns.Select(x => string.Format("({0})", x.Value)));
         yield return new PatternRestrictionModel(config)
         {
             Value = pattern,
         };
     }
 }

        static void Main(string[] args)
        {
            var images = new List<ImageInfo>();

            var imageId = 0;
            foreach (var dir in new DirectoryInfo(@"..\..\Images").GetDirectories())
            {
                var groupId = int.Parse(dir.Name.Replace("s", string.Empty)) - 1;
                foreach (var imageFile in dir.GetFiles("*.pgm"))
                {
                    images.Add(new ImageInfo
                    {
                        Image = new Mat(imageFile.FullName, LoadMode.GrayScale),
                        ImageId = imageId++,
                        ImageGroupId = groupId
                    });
                }
            }

            var model = FaceRecognizer.CreateFisherFaceRecognizer();
            model.Train(images.Select(x => x.Image), images.Select(x => x.ImageGroupId));

            var rnd = new Random();
            var randomImageId = rnd.Next(0, images.Count - 1);
            var testSample = images[randomImageId];

            Console.WriteLine("Actual group: {0}", testSample.ImageGroupId);
            Cv2.ImShow("actual", testSample.Image);

            var predictedGroupId = model.Predict(testSample.Image);
            Console.WriteLine("Predicted group: {0}", predictedGroupId);

            Cv2.WaitKey(0);
        }

        public ActionResult Agitator(int Id)
        {
            var politicalViews = new List<KeyValuePair<string, int>>();
            var agitatorHouses = dataManager.AgitatorHouseRelations.GetAll().Where(ah => ah.AgitatorId == Id && ah.HouseId.HasValue).Select(wh => wh.HouseId.Value).ToList();

            var houses = dataManager.Houses.GetAll().Where(h => agitatorHouses.Contains(h.Id) && h.Latitude.HasValue && h.Longitude.HasValue).ToList();
            var persons = dataManager.Persons.GetAll().Where(p => houses.Select(x => x.Id).Contains(p.HouseId ?? 0)).ToList();
            var voters = dataManager.Voters.GetAll().Where(v => persons.Select(x => x.Id).Contains(v.PersonId ?? 0)).ToList();
            var voterPartyRelations = dataManager.VoterPartyRelations.GetAll().ToList();
            var parties = voterPartyRelations.Where(vp => voters.Select(x => x.Id).Contains(vp.VoterId ?? 0))
                .Select(x => dataManager.Parties.Get(x.PartyId ?? 0)).ToList();

            foreach (var house in houses)
            {
                var hPersons = persons.Where(x => x.HouseId == house.Id).ToList();
                var hVoters = voters.Where(x => hPersons.Select(x2 => x2.Id).Contains(x.PersonId ?? 0)).ToList();
                var hVoterPartyRelations = voterPartyRelations.Where(x => hVoters.Select(x2 => x2.Id).Contains(x.VoterId ?? 0)).ToList();
                var hParties = parties.Where(x => hVoterPartyRelations.Select(x2 => x2.PartyId).Contains(x.Id)).ToList();

                foreach (var hParty in hParties.GroupBy(x => x.Id).Select(x => x.First()))
                {
                    politicalViews.Add(new KeyValuePair<string, int>(hParty.Name, hVoterPartyRelations.Where(x => x.PartyId == hParty.Id).Count()));
                }
            }
            var chart = new Chart(width: 200, height: 200)
            .AddSeries(
                name: "Employee",
                xValue: politicalViews.Select(p => p.Key).ToArray(),
                yValues: politicalViews.Select(p => p.Value).ToArray(),
                chartType: "Pie");
            return File(chart.GetBytes(), "image/jpeg");
        }

        public static ISet<int> GetSchemaVersionsForSubscription(List<string> capabilities)
        {
            //The first two schema versions follow the old regex, and versions 3 on follow the new one.
            if (capabilities == null)
            {
                throw new ArgumentNullException("capabilities");
            }

            var matchesOld = capabilities.Select(s => ClustersContractCapabilityRegexOld.Match(s)).Where(match => match.Success).ToList();

            var schemaVersions = new HashSet<int>(matchesOld.Select(m => Int32.Parse(m.Groups[1].Value, CultureInfo.CurrentCulture)).ToList());

            var matchesNew = capabilities.Select(s => ClustersContractCapabilityRegex.Match(s)).Where(match => match.Success).ToList();
            if (matchesNew.Count != 0)
            {
                schemaVersions.UnionWith(
                    matchesNew.Select(m => Int32.Parse(m.Groups[1].Value, CultureInfo.CurrentCulture)));
            }

            if (schemaVersions == null || !schemaVersions.Any())
            {
                throw new NotSupportedException("This subscription is not enabled for the clusters contract.");
            }

            return schemaVersions;
        }

        public static bool Save(List<RoleFunctions> rolefunctions, OracleConnection conn)
        {
            try
            {
                bool saved = false;
                string query = "INSERT INTO SYSTEMROLEFUNCTIONS (ROLEID, FUNCTIONID) values(:roleid, :functionid)";
                using (var command = conn.CreateCommand())
                {
                    command.CommandText = query;
                    command.CommandType = CommandType.Text;
                    command.BindByName = true;
                    // In order to use ArrayBinding, the ArrayBindCount property
                    // of OracleCommand object must be set to the number of records to be inserted
                    command.ArrayBindCount = rolefunctions.Count;
                    command.Parameters.Add(":roleid", OracleDbType.Int32, rolefunctions.Select(rf => rf.RoleId).ToArray(), ParameterDirection.Input);
                    command.Parameters.Add(":functionid", OracleDbType.Int32, rolefunctions.Select(rf => rf.FunctionId).ToArray(), ParameterDirection.Input);

                    int result = command.ExecuteNonQuery();
                    if (result == rolefunctions.Count)
                        saved = true;

                    return saved;
                }
            }
            catch(Exception ex)
            {
                throw ex;
            }
        }

		public RefactorCombineTableForm(Microsoft.VisualStudio.Modeling.Store store, nHydrateDiagram diagram, nHydrateModel model, Entity entity1, Entity entity2)
			: this()
		{
			_store = store;
			_model = model;
			_diagram = diagram;
			_entity1 = entity1;
			_entity2 = entity2;

			lblEntity1.Text = entity1.Name;
			lblEntity2.Text = entity2.Name;

			var fieldList = new List<Field>();
			fieldList.AddRange(entity1.Fields);
			fieldList.AddRange(entity2.Fields);
			fieldList.Remove(x => entity2.PrimaryKeyFields.Contains(x));

			if (fieldList.Select(x => x.Name.ToLower()).Count() != fieldList.Select(x => x.Name.ToLower()).Distinct().Count())
			{
				cmdApply.Enabled = false;
				lblError.Text = "Duplicate field names are not allowed.";
				lblError.Visible = true;
			}

			fieldList.ForEach(x => lstField.Items.Add(x.Name));
		}

        public void Init(PluginInitContext context)
        {
            this.context = context;
            controlPanelItems = ControlPanelList.Create(48);
            iconFolder = Path.Combine(context.CurrentPluginMetadata.PluginDirectory, @"Images\ControlPanelIcons\");
            fileType = ".bmp";

            if (!Directory.Exists(iconFolder))
            {
                Directory.CreateDirectory(iconFolder);
            }

            foreach (ControlPanelItem item in controlPanelItems)
            {
                if (!File.Exists(iconFolder + item.GUID + fileType) && item.Icon != null)
                {
                    item.Icon.ToBitmap().Save(iconFolder + item.GUID + fileType);
                }
            }

            Task.Run(() =>
            {
                var characters = controlPanelItems.Select(i => i.LocalizedString)
                    .Concat(controlPanelItems.Select(i => i.InfoTip));

                Parallel.ForEach(characters, c =>
                {
                    if (!string.IsNullOrWhiteSpace(c) && Alphabet.ContainsChinese(c))
                    {
                        Alphabet.PinyinComination(c);
                    }
                });
            });
        }

        public ILogFormat Create(Stream stream)
        {
            var savedPresets = Settings.Default.LexPresets ?? new XElement("Presets");

            var presets = new List<LexPreset>(
                from element in savedPresets.Elements("Preset")
                select new LexPreset {
                    Name = (string) element.Attribute("Name"),
                    CommonCode = (string) element.Attribute("CommonCode"),
                    SegmentCode = (string) element.Attribute("SegmentCode"),
                    RecordCode = (string) element.Attribute("RecordCode")
                });

            var selectView = new LexPresetsView();
            var viewModel = selectView.ViewModel;

            foreach (var preset in presets)
                viewModel.Presets.Add(preset);

            viewModel.SelectedPreset = viewModel.Presets.FirstOrDefault();

            viewModel.EditPreset = preset => {
                InvalidateCache(preset);
                ShowEditPresetDialog(selectView, stream, preset, presets.Select(x => x.Name));
            };

            viewModel.CreateNewPreset = () => {
                var preset = new LexPreset {
                    Name = "New Preset",
                    SegmentCode = "%%",
                    RecordCode = "%%"
                };

                return ShowEditPresetDialog(selectView, stream, preset, presets.Select(x => x.Name)) ? preset : null;
            };

            if (selectView.ShowDialog() != true)
                return null;

            Settings.Default.LexPresets =
                new XElement("Presets",
                    from preset in viewModel.Presets
                    select new XElement("Preset",
                        new XAttribute("Name", preset.Name),
                        new XAttribute("CommonCode", preset.CommonCode),
                        new XAttribute("SegmentCode", preset.SegmentCode),
                        new XAttribute("RecordCode", preset.RecordCode)));

            Settings.Default.Save();

            var selectedPreset = selectView.ViewModel.SelectedPreset;

            if (selectedPreset == null)
                return null;

            if (selectedPreset.Format != null)
                return selectedPreset.Format;

            return Compile(selectedPreset) ?? CompileManually(selectView, stream, selectedPreset);
        }

        public static void ExecuteUserCommand(string command, Dictionary<string, string> userInputsArgs)
        {
            ChassisManagerLauncher launcher = new ChassisManagerLauncher();

            List<KeyValuePair<string, string>> methodParam = new List<KeyValuePair<string, string>>();

            foreach (KeyValuePair<string, string> parm in userInputsArgs)
            {
                if (parm.Key != command && parm.Key != string.Empty)
                {
                    methodParam.Add(new KeyValuePair<string, string>(CorrectParameterName(command,parm.Key) , parm.Value));
                }
            }

            try
            {
                launcher.GetType().InvokeMember(command, BindingFlags.InvokeMethod, null, launcher,
                    methodParam.Select(d => d.Value).ToArray(),
                    null, null, methodParam.Select(d => d.Key).ToArray());
            }
            catch (TargetInvocationException ex)
            {
                ex.InnerException.Data["OriginalStackTrace"] = ex.InnerException.StackTrace;
                throw ex.InnerException;
            }
        }