C# IReadOnlyList.ToList方法代码示例

        private static IReadOnlyList<Issue> AddKompetenzenAsNodes(IReadOnlyList<Issue> issues)
        {
            var result = issues.ToList();

            var kompetenzen = issues
                .SelectMany(x => x.Kompetenzen)
                .Distinct()
                .Select(x => new Issue
                {
                    Id = x.Escape(),
                    Name = x
                });

            foreach (var issue in issues)
            {
                foreach (var kompetenz in issue.Kompetenzen)
                {
                    issue.LinksTo = issue.LinksTo.Union(new[] { kompetenz.Escape() });
                }
            }

            result.AddRange(kompetenzen);

            return result;
        }

        public SystemUpdateScheduler(IReadOnlyList<ISystemInstance> systemInstances)
        {
            var systems = systemInstances.Select(p => p.System).ToList();
            var sorted = ExecuteOrderSorter.Sort(systems);

            var systemList = systemInstances.ToList();
            // TODO
            systemList.Sort((p, q) => sorted.IndexOf(p.System).CompareTo(sorted.IndexOf(q.System)));

            UpdateBursts = new List<UpdateBurst>()
            {
                new UpdateBurst(systemList)
            };
        }

        private static bool TryParseFieldDeclaration(IReadOnlyList<IToken> tokens, out IVbField field)
        {
            field = null;

            MemberVisibility vis = MemberVisibility.Default;
            bool isConst = false;
            bool isStatic = false;

            bool hasVisibility = TryGetMemberVisibility(tokens.First(), out vis);

            var tConst = tokens.Find(AnalyzerConstants.Constant);
            var tShared = tokens.Find(AnalyzerConstants.Shared);
            var tAs = tokens.Find("As");
            var tAssign = tokens.Find("=");
            var tIsWithEvents = tokens.Find("WithEvents");

            /* Check whether the line qualifies as a field declaration.
             */
            if (tokens.ContainsAny(AnalyzerConstants.Method_Function, AnalyzerConstants.Method_Property, AnalyzerConstants.Method_Sub))
            {
                return false;
            }

            if (!hasVisibility)
            {
                if (tConst == null)
                {
                    return false;
                }
            }

            if (tAs != null)
            {
                if (tokens[tAs.Item1 - 1].Type != TokenType.Word)
                {
                    return false;
                }
            }

            IList<IToken> copy = tokens.ToList();
            if (tConst != null)
            {
                isConst = true;
                copy.RemoveAt(0);
            }

            if (tShared != null)
            {
                isStatic = true;
                copy.RemoveAt(0);
            }

            if (tIsWithEvents != null)
            {
                // TODO: Actually make use of that keyword!
                copy.RemoveAt(0);
            }

            if (hasVisibility)
            {
                copy.RemoveAt(0);
            }

            // Consume name, which is the next.
            string name = copy.First().Content;
            copy.RemoveAt(0);

            // TODO: Parse the rest.

            field = new VbField()
            {
                IsConstant = isConst,
                IsStatic = isStatic,
                Name = name,
                Location = tokens.First().Location,
                Visibility = vis,
                Type = VbTypes.Variant,
            };

            return true;
        }

        public static Type CreateType(string typeName, IReadOnlyList<IMemberDefinition> nodes, bool serializable = false, bool @sealed = false, Type parent = null, IEnumerable<Type> interfaces = null)
        {
            Type type;
            if (_typeCache.TryGetValue(typeName, out type))
                return type;

            var typeAttributes = ClassTypeAttributes;

            if (@sealed)
                typeAttributes |= TypeAttributes.Sealed;

            if (serializable)
                typeAttributes |= TypeAttributes.Serializable;

            var typeBuilder = _HorizonModule.DefineType(typeName, typeAttributes);

            List<IMemberDefinition> members;

            if (parent == null)
            {
                members = nodes.ToList();
            }
            else
            {
                typeBuilder.SetParent(parent);

                var properties = Info.Extended.Properties(parent);
                var fields = Info.Extended.Fields(parent);

                var names = properties.Select(x => x.Name).Union(fields.Select(x => x.Name)).ToList();
                members = nodes.Where(x => !names.Contains(x.Name)).ToList();

                if (parent.IsAbstract)
                {
                    //We need to implement these ourselves
                    var abstractProperties = properties.Where(x => (x.PropertyInfo.CanRead && x.PropertyInfo.GetGetMethod().IsAbstract) || (x.PropertyInfo.CanWrite && x.PropertyInfo.GetSetMethod().IsAbstract))
                                                       .Select(x => MemberDefinition.Property(x, isVirtual: true));

                    members.AddRange(abstractProperties);

                    var abstractMethods = Info.Extended.Methods(parent)
                                              .Where(x => x.MethodInfo.IsAbstract)
                                              .Where(x => !nodes.Any(n => n.Name == x.Name))
                                              .Select(x => MemberDefinition.EmptyMethod(x, isVirtual: true));

                    members.AddRange(abstractMethods);
                }
            }

            var notifyChanges = false;
            MethodBuilder raisePropertyChanged = null;
            
            if (interfaces != null)
            {
                var interfaceSet = new HashSet<Type>();
                
                foreach (var @interface in interfaces.Where(interfaceSet.Add).SelectMany(x => x.GetInterfaces()))
                    interfaceSet.Add(@interface);

                foreach (var @interface in interfaceSet)
                {
                    typeBuilder.AddInterfaceImplementation(@interface);

                    var properties = Info.Extended.Properties(@interface).Select(x => MemberDefinition.Property(x.Name, x.MemberType));
                    members = members.Union(properties).ToList();


                    var events = Info.Extended.Events(@interface);

                    if (!notifyChanges &&
                        (notifyChanges = typeof(INotifyPropertyChanged).IsAssignableFrom(@interface)))
                    {
                        foreach (var @event in events)
                        {
                            var tuple = GenerateEvent(typeBuilder, @event);

                            if (@event.Name != "PropertyChanged")
                                continue;

                            var eventBuilder = tuple.Item1;
                            var eventBackingField = tuple.Item2;

                            raisePropertyChanged = BuildOnPropertyChanged(typeBuilder, eventBuilder, eventBackingField);
                        }
                    }
                    else
                    {
                        members.AddRange(events.Select(x => new EventMemberDefinition(x.Name, x.EventHandlerType)));
                    }


                    var emptyMethods = Info.Extended.Methods(@interface).Select(method => MemberDefinition.EmptyMethod(method));
                    members.AddRange(emptyMethods);
                }
            }

            if (raisePropertyChanged != null)
            {
                foreach (var propertyDefinition in members.OfType<PropertyMemberDefinition>())
                    propertyDefinition.RaisePropertyChanged = raisePropertyChanged;
//.........这里部分代码省略.........

 public HtmlResultModel(IReadOnlyList<FeatureTable> tables)
 {
     this.Tables = tables.ToList();
     this.TableIdMap = new Dictionary<FeatureTable, string>();
 }

 // ReSharper disable once UnusedParameter.Local
 static void checkAll(IReadOnlyList<IAsi> items, String expected, Printer printer)
 {
     check(new Sequence(items.ToList()), expected, printer);
 }