C# HashSet.Single方法代码示例

        public override void OnExecute(CommandEventArgs e)
        {
            GitPushArgs args = new GitPushArgs();

            string repositoryRoot;
            var repositoryRoots = new HashSet<string>(FileSystemUtil.StringComparer);

            foreach (var projectRoot in GetAllRoots(e))
            {
                if (
                    GitTools.TryGetRepositoryRoot(projectRoot.FullPath, out repositoryRoot) &&
                    !repositoryRoots.Contains(repositoryRoot)
                )
                    repositoryRoots.Add(repositoryRoot);
            }

            if (repositoryRoots.Count > 1)
            {
                throw new InvalidOperationException("Pushing of multiple repository roots is not supported");
            }

            repositoryRoot = repositoryRoots.Single();

            switch (e.Command)
            {
                case VisualGitCommand.PendingChangesPushSpecificBranch:
                case VisualGitCommand.PendingChangesPushSpecificTag:
                    if (!QueryParameters(e, repositoryRoot, args))
                        return;
                    break;
            }

            ProgressRunnerArgs pa = new ProgressRunnerArgs();
            pa.CreateLog = true;
            pa.TransportClientArgs = args;

            GitException exception = null;

            e.GetService<IProgressRunner>().RunModal(CommandStrings.PushingSolution, pa,
                delegate(object sender, ProgressWorkerArgs a)
                {
                    using (var client = e.GetService<IGitClientPool>().GetNoUIClient())
                    {
                        try
                        {
                            client.Push(repositoryRoot, args);
                        }
                        catch (GitException ex)
                        {
                            exception = ex;
                        }
                    }
                });

            if (exception != null)
            {
                e.GetService<IVisualGitErrorHandler>().OnWarning(exception);
            }
        }

 /// <summary>
 /// Get node collection from dataGridView
 /// </summary>
 /// <returns>HashSet of nodes</returns>
 public HashSet<Node> GetNodes()
 {
     HashSet<Node> Nodes = new HashSet<Node>();
     // Enlist all nodes
     for (int row = 0; row < dataTable.Rows.Count; row++)
         Nodes.Add(new Node((string)dataTable.Rows[row][0], (int)dataTable.Rows[row][1]));
     // Create dependencies
     for (int row = 0; row < dataTable.Rows.Count; row++)
         if (dataTable.Rows[row][2] != null)
             foreach (string dependency in dataTable.Rows[row][2].ToString().Split(separators, StringSplitOptions.RemoveEmptyEntries))
                 Nodes.ElementAt(row).Dependencies.Add(Nodes.Single(new Func<Node, bool>(delegate(Node node)
                 {
                     return node.ID == dependency;
                 })));
     return Nodes;
 }

        /// <summary>
        /// Take a Dictionary of pins and write it to an XML file
        /// </summary>
        /// <param name="pinMap">A Dictionary of frame X and Y rotations to a list of pins on that frame</param>
        /// <param name="outfile">The file to write the formatted XML to</param>
        public void Pack(Dictionary<Tuple<int, int>, List<Pin>> pinMap, string outfile)
        {
            List<FrameData> frames = new List<FrameData>();

            HashSet<DissectionPinData> pins = new HashSet<DissectionPinData>();
            int nextId = 0;

            foreach (var pair in pinMap)
            {
                List<Pin> framePins = pair.Value;                                   // All the pins on this frame
                Tuple<int, int> frame = pair.Key;                                   // The 2D rotation of this frame

                FrameData frameData = new FrameData();                              // Data for the frame to be represented in XML
                frameData.Rotation = new Vector3(frame.Item1, frame.Item2, 0.0f);

                List<FramePinData> framePinDatas = new List<FramePinData>();        // The links between this frame and its pins

                foreach (Pin pin in framePins)
                {
                    DissectionPinData data = ConvertToData(pin);
                    if (pins.Add(data))
                    {
                        // This pin doesn't already exist, so give it an id
                        data.Id = nextId++;
                    }
                    else
                    {
                        // This pin is in the HashSet so get the original instance
                        data = pins.Single((DissectionPinData x) => { return x.Equals(data); });
                    }

                    framePinDatas.Add(new FramePinData(new Vector2(pin.X, pin.Y), data.Id));
                }

                frameData.Pins = framePinDatas.ToArray();
                frames.Add(frameData);
            }

            PinContainer container = new PinContainer();
            container.Frames = frames.ToArray();
            container.Pins = pins.ToArray();

            WriteXml(container, outfile);
        }

        private double CalculateRPNValue(Stack<string> RPNStack, IEnumerable<SolvedCalculatorParameter> parameters)
        {
            var resultStack = new Stack<double>();

            var parameterSet = new HashSet<SolvedCalculatorParameter>(parameters);

            while (RPNStack.Count > 0) {
                var val = RPNStack.Pop();

                if (IsNumber(val)) {
                    resultStack.Push(double.Parse(val.Replace('.', ',')));
                } else if (parameterSet.Any(x => x.Name == val)) {
                    var paramVal = parameterSet.Single(x => x.Name == val);
                    resultStack.Push(paramVal.Value);
                } else {
                    var op = this.OperatorFactory.GetOperatorByCode(val);

                    if (resultStack.Count < op.ParameterCount) {
                        throw new CalculatorException(string.Format("Not enough parameters for function {0}", op.Name));
                    }

                    var operatorParams = new List<double>();

                    for (int i = 0; i < op.ParameterCount; i++) {
                        operatorParams.Add(resultStack.Pop());
                    }

                    operatorParams.Reverse();

                    var operationResult = op.DoOperation(operatorParams);

                    resultStack.Push(operationResult);
                }
            }

            if (resultStack.Count > 1) {
                throw new CalculatorException("The equation has too many values");
            }

            return resultStack.Pop();
        }

		void UpdateCompilerComboBox()
		{
			if (listView.SelectedItems.Count > 0) {
				// Fetch list of available compiler versions
				HashSet<CompilerVersion> availableVersionsSet = new HashSet<CompilerVersion>();
				HashSet<CompilerVersion> currentVersions = new HashSet<CompilerVersion>();
				foreach (Entry entry in listView.SelectedItems) {
					if (entry.CompilerVersion != null)
						currentVersions.Add(entry.CompilerVersion);
					availableVersionsSet.AddRange(entry.Project.GetAvailableCompilerVersions());
				}
				List<CompilerVersion> availableVersions = availableVersionsSet.OrderBy(n => n.MSBuildVersion).ThenBy(n => n.DisplayName).ToList();
				if (currentVersions.Count != 1) {
					availableVersions.Insert(0, new UnchangedCompilerVersion());
				}
				// Assign available versions to newVersionComboBox
				// Unless the user has already chosen a version, automatically set the selection to the
				// current version of the chosen projects, or to 'do not change' if there are different
				// current versions.
				newCompilerSelectionChangingByCode = true;
				newVersionComboBox.ItemsSource = availableVersions;
				
				CompilerVersion oldSelectedVersion = newVersionComboBox.SelectedValue as CompilerVersion;
				if (!newCompilerSelectionSetByUser || oldSelectedVersion == null) {
					newCompilerSelectionSetByUser = false;
					if (currentVersions.Count == 1)
						newVersionComboBox.SelectedValue = currentVersions.Single();
					else
						newVersionComboBox.SelectedValue = new UnchangedCompilerVersion();
				}
				newCompilerSelectionChangingByCode = false;
				UpdateTargetFrameworkComboBox();
			}
		}

        private void btnDeleteCommander_Click(object sender, EventArgs e)
        {
            var cells = dataGridViewCommanders.SelectedCells;

            HashSet<int> rowindexes = new HashSet<int>();

            foreach (var cell in cells.OfType<DataGridViewCell>())
            {
                if (!rowindexes.Contains(cell.RowIndex))
                {
                    rowindexes.Add(cell.RowIndex);
                }
            }

            if (rowindexes.Count == 1)
            {
                var row = dataGridViewCommanders.Rows[rowindexes.Single()].DataBoundItem as EDCommander;
                var result = MessageBox.Show("Do you wish to delete commander " + row.Name + "?", "Delete commander", MessageBoxButtons.YesNo, MessageBoxIcon.Information);
                if (result == DialogResult.Yes)
                {
                    EDDConfig.Instance.DeleteCommander(row);
                    _discoveryForm.TravelControl.LoadCommandersListBox();
                    UpdateCommandersListBox();
                    _discoveryForm.RefreshHistoryAsync();           // will do a new parse on commander list adding/removing scanners
                }
            }
        }

			public CimInstanceRegularFilter(string propertyName, IEnumerable allowedPropertyValues, bool wildcardsEnabled, BehaviorOnNoMatch behaviorOnNoMatch)
			{
				HashSet<BehaviorOnNoMatch> behaviorOnNoMatches = new HashSet<BehaviorOnNoMatch>();
				foreach (object allowedPropertyValue in allowedPropertyValues)
				{
					ClientSideQuery.PropertyValueFilter propertyValueRegularFilter = new ClientSideQuery.PropertyValueRegularFilter(propertyName, allowedPropertyValue, wildcardsEnabled, behaviorOnNoMatch);
					base.AddPropertyValueFilter(propertyValueRegularFilter);
					behaviorOnNoMatches.Add(propertyValueRegularFilter.BehaviorOnNoMatch);
				}
				if (behaviorOnNoMatches.Count != 1)
				{
					base.BehaviorOnNoMatch = behaviorOnNoMatch;
					return;
				}
				else
				{
					base.BehaviorOnNoMatch = behaviorOnNoMatches.Single<BehaviorOnNoMatch>();
					return;
				}
			}

            public CimInstanceRegularFilter(string propertyName, IEnumerable allowedPropertyValues, bool wildcardsEnabled, BehaviorOnNoMatch behaviorOnNoMatch)
            {
                var valueBehaviors = new HashSet<BehaviorOnNoMatch>();

                foreach (object allowedPropertyValue in allowedPropertyValues)
                {
                    PropertyValueFilter filter =
                        new PropertyValueRegularFilter(
                            propertyName,
                            allowedPropertyValue,
                            wildcardsEnabled,
                            behaviorOnNoMatch);
                    this.AddPropertyValueFilter(filter);

                    valueBehaviors.Add(filter.BehaviorOnNoMatch);
                }

                if (valueBehaviors.Count == 1)
                {
                    this.BehaviorOnNoMatch = valueBehaviors.Single();
                }
                else
                {
                    this.BehaviorOnNoMatch = behaviorOnNoMatch;
                }
            }

        private void UpdateSeverityMenuItemsChecked()
        {
            _setSeverityErrorMenuItem.Checked = false;
            _setSeverityWarningMenuItem.Checked = false;
            _setSeverityInfoMenuItem.Checked = false;
            _setSeverityHiddenMenuItem.Checked = false;
            _setSeverityNoneMenuItem.Checked = false;

            var workspace = TryGetWorkspace() as VisualStudioWorkspaceImpl;
            if (workspace == null)
            {
                return;
            }

            HashSet<ReportDiagnostic> selectedItemSeverities = new HashSet<ReportDiagnostic>();

            var groups = _tracker.SelectedDiagnosticItems.GroupBy(item => item.AnalyzerItem.AnalyzersFolder.ProjectId);

            foreach (var group in groups)
            {
                var project = (AbstractProject)workspace.GetHostProject(group.Key);
                IRuleSetFile ruleSet = project.RuleSetFile;

                if (ruleSet != null)
                {
                    var specificOptions = ruleSet.GetSpecificDiagnosticOptions();

                    foreach (var diagnosticItem in group)
                    {
                        ReportDiagnostic ruleSetSeverity;
                        if (specificOptions.TryGetValue(diagnosticItem.Descriptor.Id, out ruleSetSeverity))
                        {
                            selectedItemSeverities.Add(ruleSetSeverity);
                        }
                        else
                        {
                            // The rule has no setting.
                            selectedItemSeverities.Add(ReportDiagnostic.Default);
                        }
                    }
                }
            }
            
            if (selectedItemSeverities.Count != 1)
            {
                return;
            }

            switch (selectedItemSeverities.Single())
            {
                case ReportDiagnostic.Default:
                    break;
                case ReportDiagnostic.Error:
                    _setSeverityErrorMenuItem.Checked = true;
                    break;
                case ReportDiagnostic.Warn:
                    _setSeverityWarningMenuItem.Checked = true;
                    break;
                case ReportDiagnostic.Info:
                    _setSeverityInfoMenuItem.Checked = true;
                    break;
                case ReportDiagnostic.Hidden:
                    _setSeverityHiddenMenuItem.Checked = true;
                    break;
                case ReportDiagnostic.Suppress:
                    _setSeverityNoneMenuItem.Checked = true;
                    break;
                default:
                    break;
            }
        }

        /// <summary>
        /// Determines whether the given query view matches the discriminator map pattern.
        /// </summary>
        internal static bool TryCreateDiscriminatorMap(EntitySet entitySet, DbExpression queryView, out DiscriminatorMap discriminatorMap)
        {
            discriminatorMap = null;

            if (queryView.ExpressionKind != DbExpressionKind.Project) { return false; }
            var project = (DbProjectExpression)queryView;

            if (project.Projection.ExpressionKind != DbExpressionKind.Case) { return false; }
            var caseExpression = (DbCaseExpression)project.Projection;
            if (project.Projection.ResultType.EdmType.BuiltInTypeKind != BuiltInTypeKind.EntityType) { return false; }

            // determine value domain by walking filter
            if (project.Input.Expression.ExpressionKind != DbExpressionKind.Filter) { return false; }
            var filterExpression = (DbFilterExpression)project.Input.Expression;

            HashSet<object> discriminatorDomain = new HashSet<object>();
            if (!ViewSimplifier.TryMatchDiscriminatorPredicate(filterExpression, (equalsExp, discriminatorValue) => discriminatorDomain.Add(discriminatorValue)))
            {
                return false;
            }
                        
            var typeMap = new List<KeyValuePair<object, EntityType>>();
            var propertyMap = new Dictionary<EdmProperty, DbExpression>();
            var relPropertyMap = new Dictionary<Query.InternalTrees.RelProperty, DbExpression>();
            var typeToRelPropertyMap = new Dictionary<EntityType, List<Query.InternalTrees.RelProperty>>();
            DbPropertyExpression discriminator = null;

            EdmProperty discriminatorProperty = null;
            for (int i = 0; i < caseExpression.When.Count; i++)
            {
                var when = caseExpression.When[i];
                var then = caseExpression.Then[i];

                var projectionVariableName = project.Input.VariableName;

                DbPropertyExpression currentDiscriminator;
                object discriminatorValue;
                if (!ViewSimplifier.TryMatchPropertyEqualsValue(when, projectionVariableName, out currentDiscriminator, out discriminatorValue)) { return false; }

                // must be the same discriminator in every case
                if (null == discriminatorProperty) { discriminatorProperty = (EdmProperty)currentDiscriminator.Property; }
                else if (discriminatorProperty != currentDiscriminator.Property) { return false; }
                discriminator = currentDiscriminator;

                // right hand side must be entity type constructor
                EntityType currentType;
                if (!TryMatchEntityTypeConstructor(then, propertyMap, relPropertyMap, typeToRelPropertyMap, out currentType)) { return false; }

                // remember type + discriminator value
                typeMap.Add(new KeyValuePair<object, EntityType>(discriminatorValue, currentType));

                // remove discriminator value from domain
                discriminatorDomain.Remove(discriminatorValue);
            }

            // make sure only one member of discriminator domain remains...
            if (1 != discriminatorDomain.Count) { return false; }

            // check default case
            EntityType elseType;
            if (null == caseExpression.Else ||
                !TryMatchEntityTypeConstructor(caseExpression.Else, propertyMap, relPropertyMap, typeToRelPropertyMap, out elseType)) { return false; }
            typeMap.Add(new KeyValuePair<object, EntityType>(discriminatorDomain.Single(), elseType));

            // Account for cases where some type in the hierarchy specifies a rel-property, but another
            // type in the hierarchy does not
            if (!CheckForMissingRelProperties(relPropertyMap, typeToRelPropertyMap))
            {
                return false;
            }

            // since the store may right-pad strings, ensure discriminator values are unique in their trimmed
            // form
            var discriminatorValues = typeMap.Select(map => map.Key);
            int uniqueValueCount = discriminatorValues.Distinct(TrailingSpaceComparer.Instance).Count();
            int valueCount = typeMap.Count;
            if (uniqueValueCount != valueCount) { return false; }

            discriminatorMap = new DiscriminatorMap(discriminator, typeMap, propertyMap, relPropertyMap, entitySet);
            return true;
        }

        public override void OnExecute(CommandEventArgs e)
        {
            GitPullArgs args = new GitPullArgs();

            string repositoryRoot;
            var repositoryRoots = new HashSet<string>(FileSystemUtil.StringComparer);

            foreach (var projectRoot in GetAllRoots(e))
            {
                if (
                    GitTools.TryGetRepositoryRoot(projectRoot.FullPath, out repositoryRoot) &&
                    !repositoryRoots.Contains(repositoryRoot)
                )
                    repositoryRoots.Add(repositoryRoot);
            }

            if (repositoryRoots.Count > 1)
            {
                throw new InvalidOperationException("Pulling of multiple repository roots is not supported");
            }

            repositoryRoot = repositoryRoots.Single();

            if (e.Command == VisualGitCommand.PendingChangesPullEx)
            {
                if (!QueryParameters(e, repositoryRoot, args))
                    return;
            }
            else
            {
                args.MergeStrategy = GitMergeStrategy.DefaultForBranch;
            }

            GitPullResult result = null;

            ProgressRunnerArgs pa = new ProgressRunnerArgs();
            pa.CreateLog = true;
            pa.TransportClientArgs = args;

            // Get a list of all documents below the specified paths that are open in editors inside VS
            HybridCollection<string> lockPaths = new HybridCollection<string>(StringComparer.OrdinalIgnoreCase);
            IVisualGitOpenDocumentTracker documentTracker = e.GetService<IVisualGitOpenDocumentTracker>();

            foreach (string file in documentTracker.GetDocumentsBelow(repositoryRoot))
            {
                if (!lockPaths.Contains(file))
                    lockPaths.Add(file);
            }

            documentTracker.SaveDocuments(lockPaths); // Make sure all files are saved before merging!

            using (DocumentLock lck = documentTracker.LockDocuments(lockPaths, DocumentLockType.NoReload))
            using (lck.MonitorChangesForReload())
            {
                GitException exception = null;

                e.GetService<IProgressRunner>().RunModal(CommandStrings.PullingSolution, pa,
                    delegate(object sender, ProgressWorkerArgs a)
                    {
                        e.GetService<IConflictHandler>().RegisterConflictHandler(args, a.Synchronizer);

                        try
                        {
                            a.Client.Pull(repositoryRoot, args, out result);
                        }
                        catch (GitException ex)
                        {
                            exception = ex;
                        }
                    });

                if (exception != null)
                {
                    e.GetService<IVisualGitErrorHandler>().OnWarning(exception);
                }
            }
        }

        public List<Account> GetUserList(string searchString)
        {
            Require.NotEmpty(searchString, nameof(searchString));

            var allProjectMemberships = _projectMembershipRepostiory.GetAllProjectMemberships().ToList();

            var allUsers = new HashSet<Account>(_userRepository.GetAllAccounts());

            var allUsersToSearchByRole =
                new HashSet<Account>(
                    allProjectMemberships.Select(membership => allUsers.Single(account => account.UserId == membership.DeveloperId)));

            var userRolesDictionary = allUsersToSearchByRole.ToDictionary(user => user,
                user =>
                    allProjectMemberships.Where(membership => membership.DeveloperId == user.UserId)
                        .Select(that => that.Role));

            return userRolesDictionary.Where(
                pair =>
                    pair.Value.Any(role => Extensions.Contains(role, searchString)))
                .Select(pair => pair.Key)
                .Union(
                    allUsers.Where(
                        account =>
                            Extensions.Contains($"{account.Firstname} {account.Lastname}",
                                searchString))).ToList();
        }

        public void HashSetExtensions_Single_ThrowsExceptionIfHashSetHasMultipleItems()
        {
            var set = new HashSet<Int32>() { 1, 2 };

            set.Single();
        }

        public void HashSetExtensions_Single_ThrowsExceptionIfHashSetIsEmpty()
        {
            var set = new HashSet<Int32>();

            set.Single();
        }

        private void btnDeleteCommander_Click(object sender, EventArgs e)
        {
            var cells = dataGridViewCommanders.SelectedCells;

            HashSet<int> rowindexes = new HashSet<int>();

            foreach (var cell in cells.OfType<DataGridViewCell>())
            {
                if (!rowindexes.Contains(cell.RowIndex))
                {
                    rowindexes.Add(cell.RowIndex);
                }
            }

            if (rowindexes.Count == 1)
            {
                var row = dataGridViewCommanders.Rows[rowindexes.Single()].DataBoundItem as EDCommander;
                var result = MessageBox.Show("Do you wish to delete commander " + row.Name + "?", "Delete commander", MessageBoxButtons.YesNo, MessageBoxIcon.Information);
                if (result == DialogResult.Yes)
                {
                    EDDConfig.Instance.DeleteCommander(row);
                    //dataGridViewCommanders.DataSource = null;           // changing data source ends up, after this, screwing the column sizing..
                    dataGridViewCommanders.DataSource = EDDConfig.Instance.listCommanders;   // can't solve it, TBD
                    dataGridViewCommanders.Update();
                    _discoveryForm.TravelControl.LoadCommandersListBox();

                }
            }
        }