Implementation of generic linked list in C #

1. Using system;
2. Using system. Collections. Generic;
3. Using system. LINQ;
4. Using system. text;
5. Using system. collections;
7. Namespace generic
8. {
9. // Implementation of simple linked list, one-way (generic)
10. Class generic class
11. {
12. Public static void main ()
13. {
15. Shortlist <string> List = new shortlist <string> ();
17. List. addlast ("500 ");
18. List. addlast ("400 ");
19. List. addlast ("300 ");
20. List. addlast ("200 ");
22. // When the generic version of ienumerable is used, foreach is also of type security. In some cases, it is impossible to write types other than string.
23. Foreach (string I in List)
24. {
25. Console. writeline (I );
26. }
28. Console. Readline ();
29. }
30. }
32. //// The definition of a generic class is similar to that of a general class. If you use a generic type declaration, this type can be used as a field member or a parameter type.
33. Class initialize listnode <t>
34. {
35. // Project value
36. Private T value;
37. Private synchronized listnode <t> next;
38. Private synchronized listnode <t> Prev;
40. Public writable listnode (T value)
41. {
42. This. value = value;
43. }
45. Public T value
46. {
47. // Read-only attribute
48. Get
49. {
50. Return this. value;
51. }
52. }
54. // Next
55. Public writable listnode <t> next
56. {
57. Get {return next ;}
58. Set {next = value ;}
59. }
61. // Previous
62. Public writable listnode <t> Prev
63. {
64. Get {return Prev ;}
65. Set {Prev = value ;}
66. }
67. }
69. Class Sequence List <t>: ienumerable <t>
70. {
71. // The first
72. Private synchronized listnode <t> first;
73. Internal internal listnode <t> first
74. {
75. Get {return first ;}
76. Set {First = value ;}
77. }
79. // Last
80. Private synchronized listnode <t> last;
81. Internal internal listnode <t> last
82. {
83. Get {return last ;}
84. Set {last = value ;}
85. }
87. // Insert from the back
88. Public writable listnode <t> addlast (T node)
89. {
90. Inclulistnode <t> newnode = new inclulistnode <t> (node );
92. If (first = NULL)
93. {
94. // The last reference is always updated.
95. First = newnode;
96. Last = first;
97. }
98. Else
99. {
100. // Point the reference of the next node of the current last node to a new object.
101. Last. Next = newnode;
102. // Update the last Node
103. Last = newnode;
104. }
106. Return newnode;
107. }
109. Public ienumerator <t> getenumerator ()
110. {
111. Repeated listnode <t> current = first;
113. While (current! = NULL)
114. {
115. Yield Return Current. value;
116. // The address of the new reference pointing to the next node
117. Current = current. Next;
118. }
120. }
122. Ienumerator ienumerable. getenumerator ()
123. {
124. Return getenumerator ();
125. }
127. }
128. }