C# Set.UnionUpdate方法代码示例

        public void SimpleValueTests()
        {
            Set<int> empty = new Set<int>();
            Set<int> a = new Set<int>(1, 2, 3);
            Set<int> b = new Set<int>(3, 4, 5);

            Set<int> a_and_b = a + b;

            Assert.AreEqual("{}", empty.ToString());
            Assert.AreEqual("{ 1, 2, 3 }", a.ToString());
            Assert.AreEqual("{ 3, 4, 5 }", b.ToString());

            Assert.AreEqual("{ 1, 2, 3, 4, 5 }", a_and_b.ToString());

            Assert.AreEqual("{}", (empty * a).ToString());
            Assert.AreEqual("{}", (a * empty).ToString());

            Assert.IsTrue(a_and_b * a == a);
            Assert.IsTrue((a_and_b * a).Equals(a));

            Assert.IsTrue(a_and_b - a == new Set<int>(4, 5));
            Assert.IsTrue(a - a == new Set<int>());
            Assert.IsTrue(a * a == a);

            Assert.IsTrue(a.IsSubsetOf(a_and_b));
            Assert.IsTrue(b.IsSubsetOf(a_and_b));
            Assert.IsTrue(a_and_b.IsSubsetOf(a_and_b));

            Assert.IsTrue(a.IsSubsetOf(a));
            Assert.IsTrue(b.IsSubsetOf(b));

            Assert.IsFalse(a.IsSubsetOf(b));
            Assert.IsFalse(b.IsSubsetOf(a));
            Assert.IsFalse(a_and_b.IsSubsetOf(a));
            Assert.IsFalse(a_and_b.IsSubsetOf(b));

            Set<int> a_copy = a.Copy();
            Set<int> b_copy = b.Copy();

            a.UnionUpdate(b);
            Assert.AreEqual(a, a_and_b);

            a.DifferenceUpdate(b);
            Assert.AreEqual(a, a_and_b - b);

            a.UnionUpdate(9);
            Assert.AreEqual(a, (a_and_b - b) + new Set<int>(9));

            a.DifferenceUpdate(1);
            Assert.AreEqual(a, (a_and_b - b) + new Set<int>(9) - new Set<int>(1));

            a_copy.IntersectionUpdate(b_copy);
            Assert.AreEqual(new Set<int>(3), a_copy);
        }

        ForeignKeyConstraint FindConstraint(string tableName, params string[] columnNames)
        {
            Table table = _database.TablesByShortName[tableName];

            Set<Column> columns = new Set<Column>();

            foreach (string columnName in columnNames)
            {
                columns.UnionUpdate(table.Columns[columnName]);
            }

            foreach (ForeignKeyConstraint constraint in table.ForeignKeyConstraints)
            {
                if (new Set<Column>(constraint.KeyColumns).Equals(columns)) return constraint;
            }

            throw new KeyNotFoundException(string.Format(
                "The table \"{0}\" does not have a constraint with the specified key columns ({1}).",
                tableName, NaturalStrings.FormatList(columnNames)));
        }

        internal static void CompareInCurrentDirectory()
        {
            List<Database> databases = LoadDatabasesInCurrentDirectory();

            // Find which tables are common to all databases:
            Set<ObjectName> allTables = new Set<ObjectName>();
            Set<ObjectName> commonTables = new Set<ObjectName>();

            if (databases.Count > 0) commonTables.UnionUpdate(databases[0].TablesByName.Keys);

            foreach (Database database in databases)
            {
                Set<ObjectName> tablesInThisDatabase = new Set<ObjectName>(database.TablesByName.Keys);

                allTables.UnionUpdate(tablesInThisDatabase);
                commonTables.IntersectionUpdate(tablesInThisDatabase);
            }

            Set<ObjectName> nonCommonTables = Set<ObjectName>.Difference(allTables, commonTables);

            Console.WriteLine(nonCommonTables);

            // Find which columns are common to all databases:
            foreach (ObjectName commonTableName in commonTables)
            {
                Set<string> allColumns = new Set<string>();
                Set<string> commonColumns = new Set<string>();

                if (databases.Count > 0)
                {
                    Set<string> columns = new Set<string>(databases[0].TablesByName[commonTableName].Columns.Keys);
                    commonColumns.UnionUpdate(columns.Map<string>(NormaliseColumnName));
                }

                foreach (Database database in databases)
                {
                    Set<string> columnsInThisTable = new Set<string>(database.TablesByName[commonTableName].Columns.Keys).Map<string>(NormaliseColumnName);

                    commonColumns.IntersectionUpdate(columnsInThisTable);
                    allColumns.UnionUpdate(columnsInThisTable);
                }

                Set<string> nonCommonColumns = Set<string>.Difference(allColumns, commonColumns);

                if (nonCommonColumns.Count > 0)
                {
                    Console.WriteLine(commonTableName.Name);
                    Console.WriteLine(nonCommonColumns);
                }
            }
        }

        public static void CreateFilteredDependenciesGraph(Database database, Table startTable, Plan plan)
        {
            Set<Table> visited = new Set<Table>();
            Stack<Table> seen = new Stack<Table>();

            seen.Push(startTable);

            // The relations that, as a precondition of the delete, must not exist:
            while (seen.Count > 0)
            {
                Table table = seen.Pop();

                visited.UnionUpdate(table);

                foreach (ForeignKeyConstraint constraint in table.ForeignKeyDependencies)
                {
                    if (plan.IsConstraintExcludedFromDependencyDiagram(constraint)) continue;

                    if (!visited.Contains(constraint.Table))
                    {
                        seen.Push(constraint.Table);
                    }
                }
            }

            CreateDependenciesGraph(database, visited);
        }

        void PopulateNoTagsSet()
        {
            _noEndTags = new Set<string>();

            _noEndTags.UnionUpdate("img");
            _noEndTags.UnionUpdate("br");
        }

        void CheckNames(Protocol protocol)
        {
            Set<string> usedDeclarationNames = new Set<string>();

            foreach (Declaration declaration in protocol.Declarations)
            {
                if (usedDeclarationNames.Contains(declaration.Identifier))
                {
                    throw new SemanticException(string.Format("The name \"{0}\" is used in more than one declaration.",
                        declaration.Identifier));
                }

                usedDeclarationNames.UnionUpdate(declaration.Identifier);

                Set<string> usedMemberNames = new Set<string>();

                foreach (DeclarationMember member in declaration.MemberBases)
                {
                    if (usedMemberNames.Contains(member.Identifier))
                    {
                        throw new SemanticException(string.Format(
                            "The name \"{0}\" in the declaration \"{1}\" is used in more " +
                            " than once within the declaration.", member.Identifier, declaration.Identifier));
                    }
                }
            }
        }

        static void CodePatchMain(string[] args)
        {
            DatabaseConnectionString connectionString = new DatabaseConnectionString();
            connectionString.ServerName = "SERVER14";
            connectionString.DatabaseName = "RMTSv2";
            connectionString.UseIntegratedAuthentication = false;
            connectionString.Username = "tmsplus";
            connectionString.Password = "cool";

            Database database;

            using (SqlConnection connection = new SqlConnection(connectionString.ToString()))
            {
                connection.Open();

                database = Database.FromConnection(connection);
            }

            Dictionary<string, string> fieldMappings = GetColumnTypeMappings(database);

            Dictionary<string, string> functionMap = new Dictionary<string,string>();
            functionMap["char"] = "FieldCasts.FromChar";
            functionMap["nvarchar"] = "FieldCasts.FromNVarChar";
            functionMap["nchar"] = "FieldCasts.FromNChar";
            functionMap["float"] = "FieldCasts.FromFloat";
            functionMap["real"] = "FieldCasts.FromReal";
            functionMap["datetime"] = "FieldCasts.FromDateTime";
            functionMap["bit"] = "FieldCasts.FromBit";
            functionMap["varchar"] = "FieldCasts.FromVarChar";
            functionMap["text"] = "FieldCasts.FromText";
            functionMap["ntext"] = "FieldCasts.FromNText";
            functionMap["numeric"] = "FieldCasts.FromNumeric";
            functionMap["int"] = "FieldCasts.FromInt";
            functionMap["image"] = "FieldCasts.FromImage";
            functionMap["varbinary"] = "FieldCasts.FromVarBinary";
            functionMap["smallint"] = "FieldCasts.FromSmallInt";
            functionMap["tinyint"] = "FieldCasts.FromTinyInt";

            DirectoryInfo info = new DirectoryInfo(@"C:\Versioning\Haulage");

            FileInfo[] files = info.GetFiles("*.vb", SearchOption.AllDirectories);

            Set<string> unknownFields = new Set<string>();

            foreach (FileInfo file in files)
            {
                using (StreamReader reader = new StreamReader(file.FullName))
                {
                    string entireFile = reader.ReadToEnd();

                    _fields.Replace(entireFile, (MatchEvaluator)delegate(Match match)
                    {
                        Console.WriteLine(match.Value);

                        string characterBeforeIdentifier = match.Groups[1].Value;
                        string recordSetIdentifier = match.Groups[2].Value;
                        string fieldName = match.Groups[3].Value;

                        string converterName = "FieldCasts.Identity";

                        if (fieldMappings.ContainsKey(fieldName.ToLower()))
                        {
                            string fieldType = fieldMappings[fieldName.ToLower()];

                            converterName = functionMap[fieldType];
                        }
                        else
                        {
                            unknownFields.UnionUpdate(fieldName.ToLower());
                        }

                        string replacementText = string.Format("{0}{1}({2}.Fields(\"{3}\").Value)",
                            characterBeforeIdentifier, converterName, recordSetIdentifier, fieldName);

                        Console.WriteLine("    " + replacementText);

                        return replacementText;
                    });
                }
            }
        }

        static Dictionary<string, string> GetColumnTypeMappings(Database database)
        {
            Dictionary<string, string> fieldMappings = new Dictionary<string, string>();

            Set<string> ambiguousMappings = new Set<string>();

            foreach (Table table in database.Tables)
            {
                foreach (KeyValuePair<string, Column> pair in table.Columns)
                {
                    string fieldNameLower = pair.Key.ToLower();

                    if (fieldMappings.ContainsKey(fieldNameLower))
                    {
                        if (fieldMappings[fieldNameLower] != pair.Value.DataType)
                        {
                            ambiguousMappings.UnionUpdate(fieldNameLower);
                        }
                    }
                    else
                    {
                        fieldMappings[fieldNameLower] = pair.Value.DataType;
                    }
                }
            }

            foreach (string ambiguousMapping in ambiguousMappings)
            {
                fieldMappings.Remove(ambiguousMapping);
            }

            return fieldMappings;
        }