C# LinkedList.Select方法代码示例

        private bool MapDestinationCtorToSource(TypeMap typeMap, ConstructorInfo destCtor, TypeInfo sourceTypeInfo,
                                                IMappingOptions options)
        {
            var parameters = new List<ConstructorParameterMap>();
            var ctorParameters = destCtor.GetParameters();

            if (ctorParameters.Length == 0 || !options.ConstructorMappingEnabled)
                return false;

            foreach (var parameter in ctorParameters)
            {
                var members = new LinkedList<MemberInfo>();

                if (!MapDestinationPropertyToSource(members, sourceTypeInfo, parameter.Name, options))
                    return false;

                var resolvers = members.Select(mi => mi.ToMemberGetter());

                var param = new ConstructorParameterMap(parameter, resolvers.ToArray());

                parameters.Add(param);
            }

            typeMap.AddConstructorMap(destCtor, parameters);

            return true;
        }

        public TypeMap CreateTypeMap(Type sourceType, Type destinationType, IMappingOptions options,
            MemberList memberList)
        {
            var sourceTypeInfo = GetTypeInfo(sourceType, options);
            var destTypeInfo = GetTypeInfo(destinationType, options.ShouldMapProperty, options.ShouldMapField, new MethodInfo[0]);

            var typeMap = new TypeMap(sourceTypeInfo, destTypeInfo, memberList);

            foreach (var destProperty in destTypeInfo.PublicWriteAccessors)
            {
                var members = new LinkedList<MemberInfo>();

                if (MapDestinationPropertyToSource(members, sourceTypeInfo, destProperty.Name, options))
                {
                    var resolvers = members.Select(mi => mi.ToMemberGetter());
                    var destPropertyAccessor = destProperty.ToMemberAccessor();

                    typeMap.AddPropertyMap(destPropertyAccessor, resolvers.Cast<IValueResolver>());
                }
            }
            if (!destinationType.IsAbstract() && destinationType.IsClass())
            {
                foreach (var destCtor in destTypeInfo.Constructors.OrderByDescending(ci => ci.GetParameters().Length))
                {
                    if (MapDestinationCtorToSource(typeMap, destCtor, sourceTypeInfo, options))
                    {
                        break;
                    }
                }
            }
            return typeMap;
        }

        //internal static ICollection<IChildMemberConfiguration> sourceToDestinationMemberMappers = new Collection<IChildMemberConfiguration>
        //{
        //    // Need to do it fixie way for prefix and postfix to work together + not specify match explicitly
        //    // Have 3 properties for Members, Methods, And External Methods
        //    // Parent goes to all
        //    new MemberConfiguration().AddMember<NameSplitMember>().AddName<PrePostfixName>(_ => _.AddStrings(p => p.Prefixes, "Get")).SetMemberInfo<AllMemberInfo>(),
        //    //new CustomizedSourceToDestinationMemberMapper().MemberNameMatch().ExtensionNameMatch().ExtensionPrefix("Get").MethodPrefix("Get").MethodNameMatch(),
        //};
        //internal static readonly ICollection<IChildMemberConfiguration> def = sourceToDestinationMemberMappers.ToList();
        public TypeMap CreateTypeMap(Type sourceType, Type destinationType, IProfileConfiguration options,
            MemberList memberList)
        {
            var sourceTypeInfo = GetTypeInfo(sourceType, options);
            var destTypeInfo = GetTypeInfo(destinationType, options);

            var typeMap = new TypeMap(sourceTypeInfo, destTypeInfo, memberList);

            foreach (var destProperty in destTypeInfo.PublicWriteAccessors)
            {
                var members = new LinkedList<MemberInfo>();

                if (MapDestinationPropertyToSource(options, sourceTypeInfo, destProperty.GetType(), destProperty.Name,
                    members))
                {
                    var resolvers = members.Select(mi => ReflectionHelper.ToMemberGetter(mi));
                    var destPropertyAccessor = ReflectionHelper.ToMemberAccessor(destProperty);

                    typeMap.AddPropertyMap(destPropertyAccessor, resolvers.Cast<IValueResolver>());
                }
            }
            if (!TypeExtensions.IsAbstract(destinationType) && TypeExtensions.IsClass(destinationType))
            {
                foreach (var destCtor in destTypeInfo.Constructors.OrderByDescending(ci => ci.GetParameters().Length))
                {
                    if (MapDestinationCtorToSource(typeMap, destCtor, sourceTypeInfo, options))
                    {
                        break;
                    }
                }
            }
            return typeMap;
        }

        public TypeMap CreateTypeMap(Type sourceType, Type destinationType, IMappingOptions options)
        {
            var sourceTypeInfo = GetTypeInfo(sourceType);
            var destTypeInfo = GetTypeInfo(destinationType);

            var typeMap = new TypeMap(sourceTypeInfo, destTypeInfo);

            foreach (var destProperty in destTypeInfo.GetPublicWriteAccessors())
            {
                var members = new LinkedList<MemberInfo>();

                if (MapDestinationPropertyToSource(members, sourceTypeInfo, destProperty.Name, options))
                {
                    var resolvers = members.Select(mi => mi.ToMemberGetter());
                    var destPropertyAccessor = destProperty.ToMemberAccessor();
            #if !SILVERLIGHT
                    typeMap.AddPropertyMap(destPropertyAccessor, resolvers);
            #else
                    typeMap.AddPropertyMap(destPropertyAccessor, resolvers.Cast<IValueResolver>());
            #endif
                }
            }
            if (!destinationType.IsAbstract && destinationType.IsClass)
            {
                foreach (var destCtor in destTypeInfo.GetConstructors().OrderByDescending(ci => ci.GetParameters().Length))
                {
                    if (MapDestinationCtorToSource(typeMap, destCtor, sourceTypeInfo, options))
                    {
                        break;
                    }
                }
            }
            return typeMap;
        }

        public IEnumerable<IMapingItem> ProcessItem(IMapingItem Item)
        {
            string[] path = Item.PackageFileName.Split(FirmwarePackage.PathSeparator);
            uint startAddress = UInt32.Parse(path.Last(), NumberStyles.HexNumber);
            byte[] data = Item.GetData();

            var sections = new LinkedList<SectionPointer>();

            int separatorLength = 0;
            int lastSignificantByteIndex = -1;
            for (int i = 0; i < data.Length; i++)
            {
                if (data[i] == Separator)
                    separatorLength++;
                else
                {
                    if (separatorLength >= MinimumSeparatorLength || sections.Count == 0)
                    {
                        if (sections.Count > 0)
                            sections.Last.Value.End = lastSignificantByteIndex;
                        sections.AddLast(new SectionPointer(i));
                        separatorLength = 0;
                    }

                    lastSignificantByteIndex = i;
                }
            }
            if (sections.Last.Value.End == -1)
                sections.Last.Value.End = lastSignificantByteIndex;
            return sections.Select(p => new MemoryMapingItem(string.Join(FirmwarePackage.PathSeparator + "",
                                                                         path.Take(path.Length - 1).Concat(new[] { (startAddress + p.Start).ToString("X") })),
                                                             data, p.Start, p.Length));
        }

 private static void PrintPath(LinkedList<Node> path)
 {
     Console.WriteLine();
     if (path.Count == 0)
     {
         Console.WriteLine("You shall not pass!");
     }
     else
     {
         Console.WriteLine(string.Join(" -> ", path.Select(x => x.Name)));
     }
     Console.Read();
 }

        public TypeMap CreateTypeMap(Type sourceType, Type destinationType, IMappingOptions options)
        {
            var sourceTypeInfo = GetTypeInfo(sourceType);
            var destTypeInfo = GetTypeInfo(destinationType);

            var typeMap = new TypeMap(sourceTypeInfo, destTypeInfo);

            foreach (var destProperty in destTypeInfo.GetPublicWriteAccessors())
            {
                var members = new LinkedList<MemberInfo>();

                if (MapDestinationPropertyToSource(members, sourceTypeInfo, destProperty.Name, options))
                {
                    var resolvers = members.Select(mi => mi.ToMemberGetter()).Cast<IValueResolver>();
                    var destPropertyAccessor = destProperty.ToMemberAccessor();
                    typeMap.AddPropertyMap(destPropertyAccessor, resolvers);
                }
            }
            return typeMap;
        }

        /// <summary>
        /// Calculates the modes of a collection of numbers using the specified discretization unit epsilon.
        /// </summary>
        /// <param name="numbers">The collection whose modes are to be calculated.</param>
        /// <param name="discretizationEpsilon">Discretization unit epsilon.</param>
        /// <returns>
        /// An array containing the arithmetic mean of all intervals
        /// (that are at most one epsilon wide) with the most occurences.
        /// </returns>
        public static double[] Modes(IEnumerable<double> numbers, double discretizationEpsilon)
        {
            if (numbers == null)
            {
                throw ArgumentNullException;
            }

            if (!numbers.Any())
            {
                throw EmptyNumbersCollectionException;
            }

            LinkedList<Interval> bestIntervals = new LinkedList<Interval>();
            int maxCount = 0;

            // Sort numbers
            IOrderedEnumerable<double> sorted = numbers.OrderBy(x => x);

            // Iterate over all maximum-sized intervals
            foreach (Interval interval in IntervalHelper.Intervals(sorted, discretizationEpsilon))
            {
                // If new maximum found, delete all maximums until now
                if (interval.ElementsInside > maxCount)
                {
                    maxCount = interval.ElementsInside;
                    bestIntervals.Clear();
                }

                // Save this interval as a maximum one if necessary
                if (interval.ElementsInside == maxCount)
                {
                    bestIntervals.AddLast(interval);
                }
            }

            // Return the arithmetic mean of the mid points
            return bestIntervals
                    .Select(x => x.MidPoint)
                    .ToArray();
        }

        private int[] FindBestSequence()
        {
            var states = new LinkedList<ActivityState>(values.Select(
                x => new ActivityState(x, E, 0)));

            while (true)
            {
                var biggestUnset = states
                    .Where(x => x.AllocatedEnergy < x.AvailableEnergy)
                    .OrderByDescending(x => x.Value)
                    .FirstOrDefault();

                if (biggestUnset == null) break;

                // take the max we can
                biggestUnset.AllocatedEnergy = biggestUnset.AvailableEnergy;

                // propagate the change
                var node = states.Find(biggestUnset);
                PropagateConstrainBackward(node);
                PropagateConstrainForward(node);
            }

            Debug.Assert(states.All(x=>x.AllocatedEnergy == x.AvailableEnergy));

            return states.Select(x => x.AllocatedEnergy).ToArray();
        }

        private bool MapDestinationCtorToSource(TypeMap typeMap, ConstructorInfo destCtor, TypeDetails sourceTypeInfo,
            IProfileConfiguration options)
        {
            var parameters = new List<ConstructorParameterMap>();
            var ctorParameters = destCtor.GetParameters();

            if (ctorParameters.Length == 0 || !options.ConstructorMappingEnabled)
                return false;

            foreach (var parameter in ctorParameters)
            {
                var members = new LinkedList<MemberInfo>();

                var canResolve = MapDestinationPropertyToSource(options, sourceTypeInfo, parameter.GetType(),
                    parameter.Name, members);

                var resolvers = members.Select(mi => ReflectionHelper.ToMemberGetter(mi));

                var param = new ConstructorParameterMap(parameter, resolvers.ToArray(), canResolve);

                parameters.Add(param);
            }

            typeMap.AddConstructorMap(destCtor, parameters);

            return true;
        }

        private int[] FindBestSequence()
        {
            var states = new LinkedList<ActivityState>(values.Select(
                x => new ActivityState(x, E)));

            while (true)
            {
                var current = states
                    .Where(x => x.AllocatedEnergy == null)
                    .OrderByDescending(x => x.Value)
                    .FirstOrDefault();

                if (current == null) break;

                Debug.Assert(current.EnergyBefore >= 0);
                Debug.Assert(current.EnergyBefore <= E);
                Debug.Assert(current.EnergyAfter >= 0);
                Debug.Assert(current.EnergyAfter <= E);
                Debug.Assert(current.EnergyAfter <= current.EnergyBefore);

                // take the max we can
                current.AllocatedEnergy = current.EnergyBefore - current.EnergyAfter;

                // propagate the change
                var node = states.Find(current);
                PropagateForward(node, current.EnergyAfter + R);
                PropagateBackward(node, current.EnergyBefore - R);
            }

            return states.Select(x => x.AllocatedEnergy.Value).ToArray();
        }

        /// <summary>
        /// 用实体多边形S的边切割切割多边形C，并插入交点到C中
        /// </summary>
        /// <param name="s1"></param>
        /// <param name="s2"></param>
        /// <param name="linkC"></param>
        /// <returns></returns>
        private static List<Intersection> CutByLine(Vertex s1, Vertex s2, LinkedList<VertexBase> linkC)
        {
            if (s1.X == s2.X)
                return CutByLineVertical(s1, s2, linkC);

            var crossXs = new List<Intersection>();

            double slope = 0, y = s1.Y;

            slope = (s2.Y - s1.Y) / (s1.X - s2.X);//s2.Y == s1.Y不单独判断，反正这里可以正常处理s2.Y == s1.Y即slope==0
            var shearedPolyC = linkC.Select(r => new Vertex(r.X, r.X * slope + r.Y) as VertexBase).ToList();//为了保存错切计算的坐标
            y = s1.X * slope + s1.Y;

            var minX = s1.X > s2.X ? s2.X : s1.X;
            var maxX = s1.X > s2.X ? s1.X : s2.X;

            //LinkedListNode<VertexBase> vertex;
            int i = -1;
            var backToHead = false;
            for (var vertex = linkC.First;
                //这样回到头部的线也可以正常被切到
                vertex != null &&
                ((vertex.Value is Vertex && vertex.Next != null) ||
                ((vertex.Value is Intersection) && ((Intersection)vertex.Value).NextC != null) ||
                    (vertex.Value is Vertex && vertex.Next == null && !backToHead) ||
                    (vertex.Value is Intersection && ((Intersection)vertex.Value).NextC == null && !backToHead));
                    
                 vertex = vertex.Next)
            {
                ++i;
                var c1 = shearedPolyC[i % shearedPolyC.Count];
                var c2 = shearedPolyC[(i + 1) % shearedPolyC.Count];

                // 重合
                if (c1.Y == c2.Y && c1.Y == y) continue;
                //不相交
                if (c1.Y > y && c2.Y > y) continue;
                if (c1.Y < y && c2.Y < y) continue;

                var x = LineCrossH(y, c1, c2);
                var npy = y - x * slope;
                var inters = new Intersection(x, npy);

                VertexBase next = null;
                if ((x > minX && x < maxX) ||
                    (c2.Y == y && x == s2.X) ||
                    (x == minX && c1.Y != y && c2.Y != y) ||
                    (x == maxX && c1.Y != y && c2.Y != y))
                {
                    inters.Name = "I" + Counter.Default.Val++;
                    if (vertex.Next == null)
                    {
                        backToHead = true;
                        next = linkC.First.Value;
                    }
                    else
                    {
                        next = vertex.Next.Value;
                    }

                    WindowLog.Default.Log("切割C的边{0}{1}得到交点{2}", vertex.Value.Name,
                        next.Name, inters.Name);

                    inters.NextC = next;
                    if (vertex.Value is Vertex)
                        ((Vertex)vertex.Value).Next = inters;
                    else if (vertex.Value is Intersection)
                        ((Intersection)vertex.Value).NextC = inters;
                    linkC.AddAfter(vertex, inters);
                    vertex = vertex.Next;
                    crossXs.Add(inters);
                }

                if (backToHead)
                    break;

                #region log
                var cLinkSb = new StringBuilder();
                var v = linkC.First.Value;
                while (v != null)
                {
                    cLinkSb.Append(v.Name);
                    if (v is Intersection)
                    {
                        var curr = v as Intersection;
                        next = curr.NextC;
                    }
                    else if (v is Vertex)
                    {
                        var curr = v as Vertex;
                        next = curr.Next;
                    }

//.........这里部分代码省略.........

        internal static List<DimensionConfiguration> GetListComponentForDimension(SwAddin swAddin, OleDbDataReader reader, LinkedList<Component2> components)
        {
            var listDetailComps = components.Select(x => x.IGetModelDoc()).Where(x => x != null)
                    .Select(
                        x => Path.GetFileNameWithoutExtension(swAddin.
                                                                  GetModelNameWithoutSuffix(
                                                                      x.GetPathName()))).ToArray();
            string tmpChar;
            string[] listDetailCompTmp = new string[listDetailComps.Count()];
            int ii = 0;
            foreach (var listDetailComp in listDetailComps)
            {
                if (listDetailComp.Length < 6)
                {
                    listDetailCompTmp[ii] = listDetailComp;
                    ii++;
                    continue;
                }
                tmpChar = listDetailComp.Substring(listDetailComp.Length - 4, 1);
                if ((listDetailComp.Last() == 'P' || listDetailComp.Last() == 'p') && (tmpChar == "#"))
                    listDetailCompTmp[ii] = listDetailComp.Substring(0, listDetailComp.Length - 4);
                else
                    listDetailCompTmp[ii] = listDetailComp;
                ii++;
            }
            //listDetailComps = new string[listDetailCompTmp.Length];
            listDetailComps = listDetailCompTmp;
            var decorsLists = new List<DimensionConfiguration>();
            int i = 0;
            while (reader.Read())
            {
                if (listDetailComps.Contains((string)reader["element"]))
                {
                    var numbPos = Convert.ToInt32(reader["number"]);

                    if (numbPos != i)
                    {
                        List<Component2> compsWithNumberCopies = new List<Component2>();
                        foreach (var comp in components)
                        {
                            string fileName = Path.GetFileNameWithoutExtension(swAddin.GetModelNameWithoutSuffix(comp.GetPathName()));
                            int rIndex = fileName.LastIndexOf('#');
                            if (rIndex != -1)
                                fileName = fileName.Remove(rIndex, fileName.Length - rIndex);
                            if (fileName == (string)reader["Element"])
                                compsWithNumberCopies.Add(comp);
                        }

                        try
                        {
                            compsWithNumberCopies.Sort(
                                (x, y) =>
                                Convert.ToInt32(x.Name.Substring(x.Name.LastIndexOf('-') + 1)).CompareTo(
                                    Convert.ToInt32(y.Name.Substring(y.Name.LastIndexOf('-') + 1))));

                        }
                        catch { }
                        if (compsWithNumberCopies.Count > 0)
                        {
                            Component2 neededComp = compsWithNumberCopies.First();
                            decorsLists.Add(new DimensionConfiguration((int)reader["number"], neededComp,
                                                                       (string)reader["caption"],
                                                                       (string)reader["idslave"], (int)reader["id"]));
                        }
                        i = numbPos;
                    }
                }
            }
            return decorsLists;
        }

        public void SelectSelect_SourceIsICollection_ReturnsExpectedValues()
        {
            ICollection<int> source = new LinkedList<int>(new List<int> { 1, 2, 3, 4, 5 });
            Func<int, int> selector = i => i + 1;

            IEnumerable<int> query = source.Select(selector).Select(selector);

            int index = 0;
            foreach (var item in query)
            {
                index++;
                var expected = selector(selector(index));
                Assert.Equal(expected, item);
            }

            Assert.Equal(source.Count, index);
        }

        private IntPtr WindowShownOrActivated(LinkedList<Tuple<Workspace, Window>> list)
        {
            var window = list.First.Value.Item2;
            var activatedWindow = window.hWnd;

            if (list.All(t => !t.Item1.IsCurrentWorkspace))
            {
                Workspace workspace;
                if (monitors.Length > 1 &&
                    (workspace = list.Select(t => t.Item1).FirstOrDefault(ws => ws.IsWorkspaceVisible)) != null)
                {
                    // the window is actually visible on another monitor
                    // (e.g. when the user has ALT-TABbed to the window across monitors)

                    if (justDeactivatedWindow)
                    {
                        // Windows is trying to activate a window from another workspace when some on the current one was
                        // destroyed or minimized. Do not allow that but instead reactivate another one from the current workspace
                        activatedWindow = DoForTopmostWindowForWorkspace(CurrentWorkspace, ActivateWindow);
                    }
                    else
                    {
                        SwitchToWorkspace(workspace.id, false);
                    }
                }
                else
                {
                    switch (window.onHiddenWindowShownAction)
                    {
                        case OnWindowCreatedOrShownAction.SwitchToWindowsWorkspace:
                            SwitchToApplication(window.hWnd);
                            break;
                        case OnWindowCreatedOrShownAction.MoveWindowToCurrentWorkspace:
                            ChangeApplicationToWorkspace(window.hWnd, CurrentWorkspace.id, list.First.Value.Item1.id);
                            break;
                        case OnWindowCreatedOrShownAction.TemporarilyShowWindowOnCurrentWorkspace:
                            CurrentWorkspace.Monitor.temporarilyShownWindows.Add(window.hWnd);
                            break;
                        case OnWindowCreatedOrShownAction.HideWindow:
                            HideWindow(window);
                            activatedWindow = DoForTopmostWindowForWorkspace(CurrentWorkspace, ActivateWindow);
                            break;
                    }
                }
            }

            return activatedWindow;
        }