C# LinkedList.Concat方法代码示例

 public long SelectData(LinkedList<KeyValuePair<string, string>> leftFilters, LinkedList<KeyValuePair<string, string>> topFilters, string aggregation)
 {
     string query = QueryBuilder.Select(new string[] { aggregation }, m_name, leftFilters.Concat(topFilters));
     SQLiteCommand cmd = new SQLiteCommand(query, m_conn);
     object o = cmd.ExecuteScalar();
     if (o is DBNull)
         return 0;
     return (long)o;
 }

        private static void SetFinalLength(DefinitionBase[] definitions, double gridFinalLength)
        {
            double occupiedLength = 0d;

            var stars = new LinkedList<DefinitionBase>();
            var nonStarDefinitions = new LinkedList<DefinitionBase>();

            foreach (DefinitionBase definition in definitions)
            {
                double minLength;

                switch (definition.UserLength.GridUnitType)
                {
                    case GridUnitType.Auto:
                        minLength = definition.MinLength;

                        definition.FinalLength = minLength.Coerce(definition.MinLength, definition.UserMaxLength);

                        occupiedLength += definition.FinalLength;
                        nonStarDefinitions.AddFirst(definition);
                        break;
                    case GridUnitType.Pixel:
                        minLength = definition.UserLength.Value;

                        definition.FinalLength = minLength.Coerce(definition.MinLength, definition.UserMaxLength);

                        occupiedLength += definition.FinalLength;
                        nonStarDefinitions.AddFirst(definition);
                        break;
                    case GridUnitType.Star:
                        double numerator = definition.UserLength.Value;
                        if (numerator.IsCloseTo(0d))
                        {
                            definition.Numerator = 0d;
                            definition.StarAllocationOrder = 0d;
                        }
                        else
                        {
                            definition.Numerator = numerator;
                            definition.StarAllocationOrder = Math.Max(definition.MinLength, definition.UserMaxLength) /
                                                             numerator;
                        }

                        stars.AddLast(definition);
                        break;
                }
            }

            if (stars.Count > 0)
            {
                DefinitionBase[] sortedStars = stars.OrderBy(o => o.StarAllocationOrder).ToArray();

                double denominator = 0d;
                foreach (DefinitionBase definitionBase in sortedStars.Reverse())
                {
                    denominator += definitionBase.Numerator;
                    definitionBase.Denominator = denominator;
                }

                foreach (DefinitionBase definition in sortedStars)
                {
                    double length;
                    if (definition.Numerator.IsCloseTo(0d))
                    {
                        length = definition.MinLength;
                    }
                    else
                    {
                        double remainingLength = (gridFinalLength - occupiedLength).EnsurePositive();
                        length = remainingLength * (definition.Numerator / definition.Denominator);
                        length = length.Coerce(definition.MinLength, definition.UserMaxLength);
                    }

                    occupiedLength += length;
                    definition.FinalLength = length;
                }
            }

            if (occupiedLength.IsGreaterThan(gridFinalLength))
            {
                IOrderedEnumerable<DefinitionBase> sortedDefinitions =
                    stars.Concat(nonStarDefinitions).OrderBy(o => o.FinalLength - o.MinLength);

                double excessLength = occupiedLength - gridFinalLength;
                int i = 0;
                foreach (DefinitionBase definitionBase in sortedDefinitions)
                {
                    double finalLength = definitionBase.FinalLength - (excessLength / (definitions.Length - i));
                    finalLength = finalLength.Coerce(definitionBase.MinLength, definitionBase.FinalLength);
                    excessLength -= definitionBase.FinalLength - finalLength;

                    definitionBase.FinalLength = finalLength;
                    i++;
                }
            }

            definitions[0].FinalOffset = 0d;
            for (int i = 1; i < definitions.Length; i++)
            {
                DefinitionBase previousDefinition = definitions[i - 1];
//.........这里部分代码省略.........

 /// <summary>
 /// Creates a dynamic chat room with multiple clients from a linked gameList. The first client in the gameList becomes leader
 /// </summary>
 /// <param name="clientList"></param>
 public ChatRoom(LinkedList<ChatPlayer> clientList)
 {
     isStatic = false;
     clients = new LinkedList<ChatPlayer>();
     clients.Concat(clients);
 }

        private IEnumerable<Column> GetPrimaryKey(Column column, Check check)
        {
            var pks = new LinkedList<Column>();

            foreach (Column c in column.ForeignKeyTable.PrimaryKeys.Values)
            {
                if (c.ForeignKeyTable == null || c.ForeignKeyTable != null && check(c.ForeignKeyTable))
                    pks.AddLast(c);
                else
                {
                    pks = (LinkedList<Column>)pks.Concat(GetPrimaryKey(c, check));
                }
            }
            return pks;
        }