C# LinkedList.AddLast方法代码示例

        private int doubleTapCountdown = 0; // number of ticks remaining to tap again for a "double-tap".

        #endregion Fields

        #region Constructors

        // default constructor.
        public ComponentManager(int screenWidth, int screenHeight)
        {
            // these are flipped because screen is in landscape.
            _screenWidth = screenHeight;
            _screenHeight = screenWidth;

            // set initial state
            this.currentState = ComponentManagerState.noMenu;

            // create component list
            componentList = new LinkedList<Component>();

            Component copperCoin = new Component(new Vector2(XNACS1Base.RandomFloat(0, XNACS1Base.World.WorldDimension.X), XNACS1Base.RandomFloat(0, XNACS1Base.World.WorldDimension.Y)));
            copperCoin.Texture = "coppercoin";
            copperCoin.RotateAngle = XNACS1Base.RandomFloat(0, 360);
            componentList.AddLast(copperCoin);

            Component goldCoin = new Component(new Vector2(XNACS1Base.RandomFloat(0, XNACS1Base.World.WorldDimension.X), XNACS1Base.RandomFloat(0, XNACS1Base.World.WorldDimension.Y)));
            goldCoin.Texture = "goldCoin";
            goldCoin.RotateAngle = XNACS1Base.RandomFloat(0, 360);
            componentList.AddLast(goldCoin);

            Component piggybank = new Component(new Vector2(XNACS1Base.RandomFloat(0, XNACS1Base.World.WorldDimension.X), XNACS1Base.RandomFloat(0, XNACS1Base.World.WorldDimension.Y)));
            piggybank.Texture = "piggybank";
            piggybank.RotateAngle = XNACS1Base.RandomFloat(0, 360);
            componentList.AddLast(piggybank);

            Component silvercoin = new Component(new Vector2(XNACS1Base.RandomFloat(0, XNACS1Base.World.WorldDimension.X), XNACS1Base.RandomFloat(0, XNACS1Base.World.WorldDimension.Y)));
            silvercoin.Texture = "silvercoin";
            silvercoin.RotateAngle = XNACS1Base.RandomFloat(0, 360);
            componentList.AddLast(silvercoin);

            // create a RemoveComponentMenu
            // removeMenu = new RemoveComponentMenu();
        }

    // Implement the data structure linked list. 
    public static void Main()
    {
        var linkedList = new LinkedList<string>();

        linkedList.AddFirst("first");
        linkedList.AddLast("second");
        Console.WriteLine(string.Join(", ", linkedList));

        linkedList.Clear();
        linkedList.AddLast("second");
        linkedList.AddFirst("first");
        Console.WriteLine(string.Join(", ", linkedList));

        string value = "first";
        Console.WriteLine("List contains \"{0}\": {1}", value, linkedList.Contains(value));

        Console.WriteLine("List contains {0} item(s)", linkedList.Count);

        var item = linkedList.Find("second");
        Console.WriteLine(item);

        linkedList.Remove("first");
        Console.WriteLine(string.Join(", ", linkedList));

        linkedList.Remove("second");
        Console.WriteLine("List contains {0} item(s): {1}", linkedList.Count, string.Join(", ", linkedList));

        linkedList.AddFirst("second");
        linkedList.AddFirst("first");
        linkedList.AddLast("third");
        Console.WriteLine(string.Join(", ", linkedList));

        linkedList.Remove("second");
        Console.WriteLine(string.Join(", ", linkedList));
    }

        public bool MoveNext()
        {
            if (personLinkedList == null) {
                    personLinkedList = new LinkedList<Person>();

                personLinkedList.AddLast(new Person {personId = 1, personName = "xxx", personLocation = "chennai"} );
                    personLinkedList.AddLast(new Person {personId = 2, personName = "YYY", personLocation = "chennai"} );
                    personLinkedList.AddLast(new Person {personId = 3, personName = "ZZZ", personLocation = "chennai"} );
                }
                if (currentObj == null && personLinkedList.First != null)
                {

                    currentObj = personLinkedList.First;
                    return true;
                }
                if ( currentObj.Next!=null)
                {
                    currentObj = currentObj.Next;
                    return true;
                }
                else
                {
                    return false;
                }
        }

        public void ProcessToTest()
        {
            var Output = new LinkedList<string>();
            var mainProcess = new MainProcess();
            var f1 = new MyProcess1();
            var f2 = new MyProcess2();

            MyProcess.DrawedHandler OnDrawed = delegate(object sender, EventArgs e)
            {
                var de = ((DrawedEventArgs)e);
                //Console.WriteLine(Output);
                Output.AddLast(Convert.ToString(de.n));
            };

            f1.Drawed += new MyProcess.DrawedHandler(OnDrawed);
            f2.Drawed += new MyProcess.DrawedHandler(OnDrawed);
            while (mainProcess.State != State.Ended)
            {
                Output.AddLast("[");
                //Output.AddLast(String.Join(",", Process.allProcesses));
                mainProcess._ExecuteProcess();
                mainProcess._DrawProcess();
                //f1._ExecuteProcess();
                Process._removeOld();
                Output.AddLast("]");
            }
            Assert.AreEqual(
                "[,1,-1,],[,2,-2,],[,3,-3,],[,4,-4,],[,3,-3,],[,2,-2,],[,1,-1,],[,0,0,],[,-1,1,],[,-2,2,],[,-3,3,],[,-4,4,],[,-4,4,],[,]",
                String.Join(",", Output)
            );
            //Console.ReadKey();
        }

        public PanningBackground()
        {
            m_parallaxEnvironments = new LinkedList<ParallaxEnvironment>();
            m_random = new Random(DateTime.Now.Millisecond);
            float t_houseDistance = Game.getInstance().getResolution().X / 10;
            m_background = Game.getInstance().Content.Load<Texture2D>("Images//Background//starry_sky_01");

            for (int i = 0; i < 50; i++)
            {
                m_parallaxEnvironments.AddLast(new ParallaxEnvironment(
                    new Vector2(t_houseDistance * i - Game.getInstance().m_camera.getRectangle().Width, -300),
                    "Images//Background//Parallax//bg_house_0" + randomNumber(1, 7).ToString(),
                    0.950f
                ));
                m_parallaxEnvironments.Last().setParrScroll(randomNumber(50, 600));
            }
            for (int i = 0; i < 25; i++)
            {
                m_parallaxEnvironments.AddLast(new ParallaxEnvironment(
                    new Vector2(t_houseDistance * i - Game.getInstance().m_camera.getRectangle().Width, randomNumber(-300, 200)),
                    "Images//Background//Parallax//clouds_0" + randomNumber(1, 4).ToString(),
                    0.950f
                ));
                m_parallaxEnvironments.Last().setParrScroll(randomNumber(50, 600));
            }
            m_logo = new Environment(new Vector2(-400, -250), "Images//GUI//logotext", 0.800f);
        }

        public ViewSourceReader(TemplateOptions options, IList<IViewSource> viewSources)
        {
            this.options = options;
            ViewSources = viewSources;
            ViewSourceQueue = new Queue<IViewSource>();
            ViewSourceModifiedChecks = new List<Func<bool>>();

            //do a for here to avoid a modified closure
            for (var index = 0; index < viewSources.Count; index++)
            {
                var viewSource = viewSources[index];
                ViewSourceModifiedChecks.Add(() => viewSource.IsModified);
                ViewSourceQueue.Enqueue(viewSource);
            }

            if (options.UseTabs)
            {
                _singleIndent = "\t";
            }
            else
            {
                _singleIndent = string.Empty.PadLeft(options.IndentSize);
            }
            inputLines = new LinkedList<InputLine>();
            inputLines.AddLast(new InputLine(string.Empty, 0, options.IndentSize));
            inputLines.AddLast(new InputLine(EofMarkupRule.SignifierChar, 1, options.IndentSize));
            CurrentNode = inputLines.First.Next;
        }

        /// <summary>
        /// Analyzes the specified input and generates a list of lexemes.
        /// </summary>
        /// <param name="input">The input.</param>
        /// <param name="throwOnError">If set to <c>true</c> an exception will be thrown on error.</param>
        /// <returns>
        /// A <see cref="Lexemes" />.
        /// </returns>
        /// <exception cref="LexicalException">Thrown if input is invalid.</exception>
        public Result<Lexemes, LexicalError> Analyze(string input, bool throwOnError)
        {
            var lexemes = new LinkedList<Lexeme>();
            if (string.IsNullOrEmpty(input))
            {
                return GetError(input, throwOnError, 0);
            }

            var characterPosition = 0;
            while (characterPosition < input.Length)
            {
                var currentInput = input.Substring(characterPosition);
                var lexeme = this.FindLexeme(currentInput, characterPosition);
                if (lexeme != null)
                {
                    characterPosition += lexeme.Token.Length;
                    lexemes.AddLast(lexeme);
                }
                else
                {
                    return GetError(input[characterPosition].ToString(), throwOnError, characterPosition);
                }
            }

            lexemes.AddLast(new Lexeme(string.Empty, TokenType.End, characterPosition));
            return Result.Success(new Lexemes(lexemes));
        }

        public Level_3()
            : base()
        {
            SoundEngine.PlayBackgroundMusic(@"sounds\soundtracks\level3.mp3");
            Lvl = 3;
            Enemies = new LinkedList<Enemy>();

            t = 0;
            forward = true;

            Ticks = new LinkedList<int>();
            Ticks.AddLast(50);
            Ticks.AddLast(100);
            Ticks.AddLast(150);
            Ticks.AddLast(200);
            Ticks.AddLast(400);

            EnemyMovement[] m = new EnemyMovement[3];
            m[0].SpeedX = -3;
            m[0].SpeedY = 3;
            m[0].steps = 30;
            m[1].SpeedX = -3;
            m[1].SpeedY = 0;
            m[1].steps = 120;
            m[2].SpeedX = 3;
            m[2].SpeedY = 0;
            m[2].steps = 120;

            Enemy e = new Enemy(800, 100, m, 0, ITERATION * 20);
            Enemies.AddFirst(e);
        }

        public static RequestLine Parse(Stream stream)
        {
            int b = stream.ReadByte();
            while (b == CR || b == LF)
            {
                b = stream.ReadByte();
            }

            var bytes = new LinkedList<byte>();
            bytes.AddLast((byte) b);

            while (true)
            {
                b = stream.ReadByte();
                if (b == CR || b < 0)
                {
                    stream.ReadByte();
                    break;
                }
                bytes.AddLast((byte) b);
            }

            var text = Encoding.Default.GetString(bytes.ToArray());
            var parts = text.Split(' ');

            if (parts.Length == 3)
            {
                return new RequestLine(parts[0], parts[1], parts[2]);
            }

            throw new InvalidRequestException("Invalid Request Line.");
        }

        static int NumAños(Relación[] lista, int N, int víctima) {
            LinkedList<Relación> cola = new LinkedList<Relación>();
            int[] veces = Enumerable.Range(0, N).Select(x => 0).ToArray();
            Relación aux;

            foreach(Relación x in Conjunto(lista, víctima)) {
                cola.AddLast(x);
            }
            veces[víctima - 1] = 1;
            //Console.WriteLine("V: " + veces.Select(x => x.ToString())
            //                               .Aggregate((x, xs) => x + " " + xs));

            while(cola.Count() > 0) {
                aux = cola.First();
                cola.RemoveFirst();
                veces[aux.necesita - 1] = veces[aux.asignatura - 1] + 1;
                //Console.WriteLine("Asig: " + aux.asignatura + " Nece: " + aux.necesita);
                //Console.WriteLine("V: " + veces.Select(x => x.ToString())
                //                               .Aggregate((x, xs) => x + " " + xs));
                foreach(Relación x in Conjunto(lista, aux.necesita)) {
                    cola.AddLast(x);
                }
            }

            return veces.Max();
        }

		public void ProcessToTest()
		{
			var Output = new LinkedList<string>();
			var mainProcess = new MainProcess();
			var f1 = new MyProcess1();
			var f2 = new MyProcess2();

			MyProcess.DrawedHandler OnDrawed = delegate(object sender, EventArgs e)
			{
				var de = ((DrawedEventArgs)e);
				Console.WriteLine(":" + Convert.ToString(de.n));
				Output.AddLast(Convert.ToString(de.n));
			};

			f1.Drawed += new MyProcess.DrawedHandler(OnDrawed);
			f2.Drawed += new MyProcess.DrawedHandler(OnDrawed);
			while (mainProcess.State != State.Ended)
			{
				Output.AddLast("[");
				//Output.AddLast(String.Join(",", Process.allProcesses));
				mainProcess.ExecuteTree();
				mainProcess.DrawTree(null);
				//f1._ExecuteProcess();
				//Console.WriteLine("RemoveOld[1/2]");
                ProcessBase._RemoveOld();
				//Console.WriteLine("RemoveOld[2/2]");
				Output.AddLast("]");
			}
			//Console.ReadKey();
		}

 /// <summary>
 /// Creates a chat room designed for use during gameplay. This is a static room with only the 2 competing players
 /// </summary>
 /// <param name="clientList"></param>
 public ChatRoom(Pair<ChatPlayer> clientList)
 {
     isStatic = true;
     clients = new LinkedList<ChatPlayer>();
     clients.AddLast(clientList.First);
     clients.AddLast(clientList.Second);
 }

		public DialogShipGroupColumnFilter( DataGridView target, ShipGroupData group ) {
			InitializeComponent();


			var rows = new LinkedList<DataGridViewRow>();
			var row = new DataGridViewRow();

			row.CreateCells( ColumnView );
			row.SetValues( "(全て)", null, null, "-" );
			row.Cells[ColumnView_Width.Index].ReadOnly = true;
			rows.AddLast( row );

			foreach ( var c in group.ViewColumns.Values.OrderBy( c => c.DisplayIndex ) ) {
				row = new DataGridViewRow();
				row.CreateCells( ColumnView );
				row.SetValues( target.Columns[c.Name].HeaderText, c.Visible, c.AutoSize, c.Width );
				row.Cells[ColumnView_Width.Index].ValueType = typeof( int );
				row.Tag = c.Name;
				rows.AddLast( row );
			}

			ColumnView.Rows.AddRange( rows.ToArray() );


			ScrLkColumnCount.Minimum = 0;
			ScrLkColumnCount.Maximum = group.ViewColumns.Count;
			ScrLkColumnCount.Value = group.ScrollLockColumnCount;
		}

        public override void PreGo(double time)
        {
            toGo = new LinkedList<double>();
            toGoTime = time;
            IVehicle nextVehicle = null;
            foreach (var vehicle in vehicles)
            {
                var lookAhead = vehicle.LookAhead;
                var position = vehiclePosition[vehicle];

                if (nextVehicle == null)
                {
                    if (length - position > lookAhead)
                    {
                        toGo.AddLast(length - position);
                    }
                    else if (IsBlocked)
                    {
                        toGo.AddLast(length - position);
                    }
                    else
                    {
                        toGo.AddLast(length - position + outputPaths[0].ObstacleDistance(lookAhead - (length - position)));
                    }
                }
                else
                {
                    toGo.AddLast(vehiclePosition[nextVehicle] - vehiclePosition[vehicle] - nextVehicle.Length);
                }

                nextVehicle = vehicle;
            }
        }

        /// <summary>
        ///
        /// </summary>
        /// <param name="s"></param>
        /// <param name="t"></param>
        /// <param name="parent"></param>
        /// <returns></returns>
        public bool Bfs(int s, int t, int[] parent)
        {
            PopulateListNodeVisited();

            LinkedList<int> queue = new LinkedList<int>();
            queue.AddLast(s);
            Visited[s] = true;
            parent[s] = -1;

            // Standard BFS Loop
            while (queue.Count() != 0)
            {
                int u = queue.First();
                queue.RemoveFirst();

                for (int v = 0; v < NumberOfNodes; v++)
                {
                    if ((Visited[v] == false) && (PathTwoDimensionArray[u, v] > 0))
                    {
                        queue.AddLast(v);
                        parent[v] = u;
                        Visited[v] = true;
                    }
                }
            }
            return (Visited[t] == true);
        }