How to initialize a List T to a given size as opposed to capacity

Question

NET offers a generic list container whose performance is almost identical  see Performance of Arrays vs  Lists question   However they are quite different in initialization    Arrays are very easy to initialize with a default value  and by definition they already have certain size   string   Ar   new string 10     Which allows one to safely assign random items  say   Ar 5   hello     with list things are more tricky  I can see two ways of doing the same initialization  neither of which is what you would call elegant   List lt string gt  L   new List lt string gt  10   for  int i 0 i lt 10 i    L Add null     or  string   Ar   new string 10   List lt string gt  L   new List lt string gt  Ar     What would be a cleaner way   EDIT  The answers so far refer to capacity  which is something else than pre-populating a list  For example  on a list just created with a capacity of 10  one cannot do L 2   somevalue   EDIT 2  People wonder why I want to use lists this way  as it is not the way they are intended to be used  I can see two reasons    One could quite convincingly argue that lists are the  next generation  arrays  adding flexibility with almost no penalty  Therefore one should use them by default  I m pointing out they might not be as easy to initialize  What I m currently writing is a base class offering default functionality as part of a bigger framework  In the default functionality I offer  the size of the List is known in advanced and therefore I could have used an array  However  I want to offer any base class the chance to dynamically extend it and therefore I opt for a list

User · Answer

If I understand correctly  you want the List lt T gt  version of new T size   without the overhead of adding values to it  If you are not afraid the implementation of List lt T gt  will change dramatically in the future  and in this case I believe the probability is close to 0   you can use reflection      public static List lt T gt  NewOfSize lt T gt  int size            var list   new List lt T gt  size           var sizeField   list GetType   GetField  quot  size quot  BindingFlags Instance BindingFlags NonPublic           sizeField SetValue list  size           return list         Note that this takes into account the default functionality of the underlying array to prefill with the default value of the item type  All int arrays will have values of 0 and all reference type arrays will have values of null  Also note that for a list of reference types  only the space for the pointer to each item is created  If you  for some reason  decide on not using reflection  I would have liked to offer an option of AddRange with a generator method  but underneath List lt T gt  just calls Insert a zillion times  which doesn t serve  I would also like to point out that the Array class has a static method called ResizeArray  if you want to go the other way around and start from Array  To end  I really hate when I ask a question and everybody points out that it s the wrong question  Maybe it is  and thanks for the info  but I would still like an answer  because you have no idea why I am asking it  That being said  if you want to create a framework that has an optimal use of resources  List lt T gt  is a pretty inefficient class for anything than holding and adding stuff to the end of a collection

User · Answer

Initializing the contents of a list like that isn t really what lists are for  Lists are designed to hold objects  If you want to map particular numbers to particular objects  consider using a key-value pair structure like a hash table or dictionary instead of a list

User · Answer

A notice about IList  MSDN IList Remarks   IList implementations fall into three categories  read-only  fixed-size  and variable-size         For the generic version of this interface  see  System Collections Generic IList lt T gt     IList lt T gt  does NOT inherits from IList  but List lt T gt  does implement both IList lt T gt  and IList   but is always variable-size  Since  NET 4 5  we have also IReadOnlyList lt T gt  but AFAIK  there is no fixed-size generic List which would be what you are looking for

User · Answer

Initializing the contents of a list like that isn t really what lists are for  Lists are designed to hold objects  If you want to map particular numbers to particular objects  consider using a key-value pair structure like a hash table or dictionary instead of a list

User · Answer

You seem to be emphasizing the need for a positional association with your data  so wouldn t an associative array be more fitting   Dictionary lt int  string gt  foo   new Dictionary lt int  string gt     foo 2     string

User · Answer

If you want to initialize the list with N elements of some fixed value   public List lt T gt  InitList lt T gt  int count  T initValue      return Enumerable Repeat initValue  count  ToList

User · Answer

You can use Linq to cleverly initialize your list with a default value    Similar to David B s answer    var defaultStrings    new int 10   Select x   gt   my value   ToList      Go one step farther and initialize each string with distinct values  string 1    string 2    string 3   etc   int x   1  var numberedStrings    new int 10   Select x   gt   string     x    ToList

User · Answer

string    temp   new string     1   2   3    List lt string gt  temp2   temp ToList

User · Answer

The accepted answer  the one with the green check mark  has an issue   The problem   var result   Lists Repeated new MyType    sizeOfList      each item in the list references the same MyType   object    if you edit item 1 in the list  you are also editing item 2 in the list   I recommend changing the line above to perform a copy of the object   There are many different articles about that     String MemberwiseClone   method called through reflection doesn  39 t work  why  https   code msdn microsoft com windowsdesktop CSDeepCloneObject-8a53311e   If you want to initialize every item in your list with the default constructor  rather than NULL  then add the following method   public static List lt T gt  RepeatedDefaultInstance lt T gt  int count                List lt T gt  ret   new List lt T gt  count           for  var i   0  i  lt  count  i                          ret Add  T Activator CreateInstance typeof T                       return ret

User · Answer

Use the constructor which takes an int   capacity   as an argument   List lt string gt    new List lt string gt  10     EDIT  I should add that I agree with Frederik   You are using the List in a way that goes against the entire reasoning behind using it in the first place   EDIT2      EDIT 2  What I m currently writing is a base class offering default functionality as part of a bigger framework  In the default functionality I offer  the size of the List is known in advanced and therefore I could have used an array  However  I want to offer any base class the chance to dynamically extend it and therefore I opt for a list    Why would anyone need to know the size of a List with all null values   If there are no real values in the list  I would expect the length to be 0   Anyhow  the fact that this is cludgy demonstrates that it is going against the intended use of the class

User · Answer

Use the constructor which takes an int   capacity   as an argument   List lt string gt    new List lt string gt  10     EDIT  I should add that I agree with Frederik   You are using the List in a way that goes against the entire reasoning behind using it in the first place   EDIT2      EDIT 2  What I m currently writing is a base class offering default functionality as part of a bigger framework  In the default functionality I offer  the size of the List is known in advanced and therefore I could have used an array  However  I want to offer any base class the chance to dynamically extend it and therefore I opt for a list    Why would anyone need to know the size of a List with all null values   If there are no real values in the list  I would expect the length to be 0   Anyhow  the fact that this is cludgy demonstrates that it is going against the intended use of the class

User · Answer

A notice about IList  MSDN IList Remarks   IList implementations fall into three categories  read-only  fixed-size  and variable-size         For the generic version of this interface  see  System Collections Generic IList lt T gt     IList lt T gt  does NOT inherits from IList  but List lt T gt  does implement both IList lt T gt  and IList   but is always variable-size  Since  NET 4 5  we have also IReadOnlyList lt T gt  but AFAIK  there is no fixed-size generic List which would be what you are looking for

User · Answer

You can use Linq to cleverly initialize your list with a default value    Similar to David B s answer    var defaultStrings    new int 10   Select x   gt   my value   ToList      Go one step farther and initialize each string with distinct values  string 1    string 2    string 3   etc   int x   1  var numberedStrings    new int 10   Select x   gt   string     x    ToList

User · Answer

The accepted answer  the one with the green check mark  has an issue   The problem   var result   Lists Repeated new MyType    sizeOfList      each item in the list references the same MyType   object    if you edit item 1 in the list  you are also editing item 2 in the list   I recommend changing the line above to perform a copy of the object   There are many different articles about that     String MemberwiseClone   method called through reflection doesn  39 t work  why  https   code msdn microsoft com windowsdesktop CSDeepCloneObject-8a53311e   If you want to initialize every item in your list with the default constructor  rather than NULL  then add the following method   public static List lt T gt  RepeatedDefaultInstance lt T gt  int count                List lt T gt  ret   new List lt T gt  count           for  var i   0  i  lt  count  i                          ret Add  T Activator CreateInstance typeof T                       return ret

User · Answer

Initializing the contents of a list like that isn t really what lists are for  Lists are designed to hold objects  If you want to map particular numbers to particular objects  consider using a key-value pair structure like a hash table or dictionary instead of a list

User · Answer

If you want to initialize the list with N elements of some fixed value   public List lt T gt  InitList lt T gt  int count  T initValue      return Enumerable Repeat initValue  count  ToList

User · Answer

string    temp   new string     1   2   3    List lt string gt  temp2   temp ToList

User · Answer

If you want to initialize the list with N elements of some fixed value   public List lt T gt  InitList lt T gt  int count  T initValue      return Enumerable Repeat initValue  count  ToList

User · Answer

string    temp   new string     1   2   3    List lt string gt  temp2   temp ToList

User · Answer

Use the constructor which takes an int   capacity   as an argument   List lt string gt    new List lt string gt  10     EDIT  I should add that I agree with Frederik   You are using the List in a way that goes against the entire reasoning behind using it in the first place   EDIT2      EDIT 2  What I m currently writing is a base class offering default functionality as part of a bigger framework  In the default functionality I offer  the size of the List is known in advanced and therefore I could have used an array  However  I want to offer any base class the chance to dynamically extend it and therefore I opt for a list    Why would anyone need to know the size of a List with all null values   If there are no real values in the list  I would expect the length to be 0   Anyhow  the fact that this is cludgy demonstrates that it is going against the intended use of the class

User · Answer

Why are you using a List if you want to initialize it with a fixed value   I can understand that -for the sake of performance- you want to give it an initial capacity  but isn t one of the advantages of a list over a regular array that it can grow when needed    When you do this   List lt int gt    new List lt int gt  100     You create a list whose capacity is 100 integers   This means that your List won t need to  grow  until you add the 101th item  The underlying array of the list will be initialized with a length of 100

User · Answer

Use the constructor which takes an int   capacity   as an argument   List lt string gt    new List lt string gt  10     EDIT  I should add that I agree with Frederik   You are using the List in a way that goes against the entire reasoning behind using it in the first place   EDIT2      EDIT 2  What I m currently writing is a base class offering default functionality as part of a bigger framework  In the default functionality I offer  the size of the List is known in advanced and therefore I could have used an array  However  I want to offer any base class the chance to dynamically extend it and therefore I opt for a list    Why would anyone need to know the size of a List with all null values   If there are no real values in the list  I would expect the length to be 0   Anyhow  the fact that this is cludgy demonstrates that it is going against the intended use of the class

User · Answer

Create an array with the number of items you want first and then convert the array in to a List   int   fakeArray   new int 10    List lt int gt  list   fakeArray ToList

User · Answer

You seem to be emphasizing the need for a positional association with your data  so wouldn t an associative array be more fitting   Dictionary lt int  string gt  foo   new Dictionary lt int  string gt     foo 2     string

User · Answer

This is a sample I used for my unit test  I created a list of class object  Then I used forloop to add  X  number of objects that I am expecting from the service  This way you can add initialize a List for any given size   public void TestMethod1                 var expected   new List lt DotaViewer Interface DotaHero gt             for  int i   0  i  lt  22  i     You add empty initialization here                       var temp   new DotaViewer Interface DotaHero                expected Add temp                     var nw   new DotaHeroCsvService            var items   nw GetHero             CollectionAssert AreEqual expected items             Hope I was of help to you guys

User · Answer

Initializing the contents of a list like that isn t really what lists are for  Lists are designed to hold objects  If you want to map particular numbers to particular objects  consider using a key-value pair structure like a hash table or dictionary instead of a list

User · Answer

This is a sample I used for my unit test  I created a list of class object  Then I used forloop to add  X  number of objects that I am expecting from the service  This way you can add initialize a List for any given size   public void TestMethod1                 var expected   new List lt DotaViewer Interface DotaHero gt             for  int i   0  i  lt  22  i     You add empty initialization here                       var temp   new DotaViewer Interface DotaHero                expected Add temp                     var nw   new DotaHeroCsvService            var items   nw GetHero             CollectionAssert AreEqual expected items             Hope I was of help to you guys

User · Answer

You seem to be emphasizing the need for a positional association with your data  so wouldn t an associative array be more fitting   Dictionary lt int  string gt  foo   new Dictionary lt int  string gt     foo 2     string

User · Answer

Create an array with the number of items you want first and then convert the array in to a List   int   fakeArray   new int 10    List lt int gt  list   fakeArray ToList

User · Answer

List lt string gt  L   new List lt string gt    new string 10

User · Answer

Why are you using a List if you want to initialize it with a fixed value   I can understand that -for the sake of performance- you want to give it an initial capacity  but isn t one of the advantages of a list over a regular array that it can grow when needed    When you do this   List lt int gt    new List lt int gt  100     You create a list whose capacity is 100 integers   This means that your List won t need to  grow  until you add the 101th item  The underlying array of the list will be initialized with a length of 100

User · Answer

If I understand correctly  you want the List lt T gt  version of new T size   without the overhead of adding values to it  If you are not afraid the implementation of List lt T gt  will change dramatically in the future  and in this case I believe the probability is close to 0   you can use reflection      public static List lt T gt  NewOfSize lt T gt  int size            var list   new List lt T gt  size           var sizeField   list GetType   GetField  quot  size quot  BindingFlags Instance BindingFlags NonPublic           sizeField SetValue list  size           return list         Note that this takes into account the default functionality of the underlying array to prefill with the default value of the item type  All int arrays will have values of 0 and all reference type arrays will have values of null  Also note that for a list of reference types  only the space for the pointer to each item is created  If you  for some reason  decide on not using reflection  I would have liked to offer an option of AddRange with a generator method  but underneath List lt T gt  just calls Insert a zillion times  which doesn t serve  I would also like to point out that the Array class has a static method called ResizeArray  if you want to go the other way around and start from Array  To end  I really hate when I ask a question and everybody points out that it s the wrong question  Maybe it is  and thanks for the info  but I would still like an answer  because you have no idea why I am asking it  That being said  if you want to create a framework that has an optimal use of resources  List lt T gt  is a pretty inefficient class for anything than holding and adding stuff to the end of a collection

User · Answer

Why are you using a List if you want to initialize it with a fixed value   I can understand that -for the sake of performance- you want to give it an initial capacity  but isn t one of the advantages of a list over a regular array that it can grow when needed    When you do this   List lt int gt    new List lt int gt  100     You create a list whose capacity is 100 integers   This means that your List won t need to  grow  until you add the 101th item  The underlying array of the list will be initialized with a length of 100

User · Answer

string    temp   new string     1   2   3    List lt string gt  temp2   temp ToList

User · Answer

A bit late but first solution you proposed seems far cleaner to me   you dont allocate memory twice  Even List constrcutor needs to loop through array in order to copy it  it doesn t even know by advance there is only null elements inside   1  - allocate N - loop N Cost  1   allocate N    N   loop iteration  2  - allocate N - allocate N   loop    Cost   2   allocate N    N   loop iteration  However List s allocation an loops might be faster since List is a built-in class  but C  is jit-compiled sooo

User · Answer

If you want to initialize the list with N elements of some fixed value   public List lt T gt  InitList lt T gt  int count  T initValue      return Enumerable Repeat initValue  count  ToList

User · Answer

A bit late but first solution you proposed seems far cleaner to me   you dont allocate memory twice  Even List constrcutor needs to loop through array in order to copy it  it doesn t even know by advance there is only null elements inside   1  - allocate N - loop N Cost  1   allocate N    N   loop iteration  2  - allocate N - allocate N   loop    Cost   2   allocate N    N   loop iteration  However List s allocation an loops might be faster since List is a built-in class  but C  is jit-compiled sooo

User · Answer

This is an old question  but I have two solutions  One is fast and dirty reflection  the other is a solution that actually answers the question  set the size not the capacity  while still being performant  which none of the answers here do   Reflection This is quick and dirty  and should be pretty obvious what the code does  If you want to speed it up  cache the result of GetField  or create a DynamicMethod to do it  public static void SetSize lt T gt  this List lt T gt  l  int newSize    gt      l GetType   GetField  quot  size quot   BindingFlags NonPublic   BindingFlags Instance  SetValue l  10    Obviously a lot of people will be hesitant to put such code into production   ICollection lt T gt  This solution is based around the fact that the constructor List IEnumerable lt T gt  collection  optimizes for ICollection lt T gt  and immediately adjusts the size to the correct amount  without iterating it  It then calls the collections CopyTo to do the copy  The code is as follows  public List IEnumerable lt T gt  collection             ICollection lt T gt  c   collection as ICollection lt T gt       if  collection is ICollection lt T gt  c                int count   c Count          if  count    0                         items   s emptyArray                    else                items   new T count               c CopyTo  items  0                size   count                       So we can completely optimally pre-initialize the List to the correct size  without any extra copying  How so  By creating an ICollection lt T gt  object that does nothing other than return a Count  Specifically  we will not implement anything in CopyTo which is the only other function called  private class SizeCollection lt T gt    ICollection lt T gt        public SizeCollection int size    gt          Count   size       public void Add T i        public void Clear         public bool Contains T i   gt true      public void CopyTo T  a  int i        public bool Remove T i   gt true      public int Count  get       public bool IsReadOnly  gt true      public IEnumerator lt T gt  GetEnumerator    gt null      IEnumerator IEnumerable GetEnumerator    gt null     public List lt T gt  InitializedList lt T gt  int size    gt      new List lt T gt  new SizeCollection lt T gt  size     We could in theory do the same thing for AddRange InsertRange for an existing array  which also accounts for ICollection lt T gt   but the code there creates a new array for the supposed items  then copies them in  In such case  it would be faster to just empty-loop Add  public void SetSize lt T gt  this List lt T gt  l  int size        if size  lt  l Count          l RemoveRange size  l Count - size       else         for size -  l Count  size  gt  0  size--              l Add default T

User · Answer

I can t say I need this very often - could you give more details as to why you want this  I d probably put it as a static method in a helper class   public static class Lists       public static List lt T gt  RepeatedDefault lt T gt  int count                return Repeated default T   count              public static List lt T gt  Repeated lt T gt  T value  int count                List lt T gt  ret   new List lt T gt  count           ret AddRange Enumerable Repeat value  count            return ret            You could use Enumerable Repeat default T   count  ToList   but that would be inefficient due to buffer resizing   Note that if T is a reference type  it will store count copies of the reference passed for the value parameter - so they will all refer to the same object  That may or may not be what you want  depending on your use case   EDIT  As noted in comments  you could make Repeated use a loop to populate the list if you wanted to  That would be slightly faster too  Personally I find the code using Repeat more descriptive  and suspect that in the real world the performance difference would be irrelevant  but your mileage may vary

User · Answer

Why are you using a List if you want to initialize it with a fixed value   I can understand that -for the sake of performance- you want to give it an initial capacity  but isn t one of the advantages of a list over a regular array that it can grow when needed    When you do this   List lt int gt    new List lt int gt  100     You create a list whose capacity is 100 integers   This means that your List won t need to  grow  until you add the 101th item  The underlying array of the list will be initialized with a length of 100

User · Answer

I can t say I need this very often - could you give more details as to why you want this  I d probably put it as a static method in a helper class   public static class Lists       public static List lt T gt  RepeatedDefault lt T gt  int count                return Repeated default T   count              public static List lt T gt  Repeated lt T gt  T value  int count                List lt T gt  ret   new List lt T gt  count           ret AddRange Enumerable Repeat value  count            return ret            You could use Enumerable Repeat default T   count  ToList   but that would be inefficient due to buffer resizing   Note that if T is a reference type  it will store count copies of the reference passed for the value parameter - so they will all refer to the same object  That may or may not be what you want  depending on your use case   EDIT  As noted in comments  you could make Repeated use a loop to populate the list if you wanted to  That would be slightly faster too  Personally I find the code using Repeat more descriptive  and suspect that in the real world the performance difference would be irrelevant  but your mileage may vary

User · Answer

You seem to be emphasizing the need for a positional association with your data  so wouldn t an associative array be more fitting   Dictionary lt int  string gt  foo   new Dictionary lt int  string gt     foo 2     string

User · Answer

I can t say I need this very often - could you give more details as to why you want this  I d probably put it as a static method in a helper class   public static class Lists       public static List lt T gt  RepeatedDefault lt T gt  int count                return Repeated default T   count              public static List lt T gt  Repeated lt T gt  T value  int count                List lt T gt  ret   new List lt T gt  count           ret AddRange Enumerable Repeat value  count            return ret            You could use Enumerable Repeat default T   count  ToList   but that would be inefficient due to buffer resizing   Note that if T is a reference type  it will store count copies of the reference passed for the value parameter - so they will all refer to the same object  That may or may not be what you want  depending on your use case   EDIT  As noted in comments  you could make Repeated use a loop to populate the list if you wanted to  That would be slightly faster too  Personally I find the code using Repeat more descriptive  and suspect that in the real world the performance difference would be irrelevant  but your mileage may vary

User · Answer

I can t say I need this very often - could you give more details as to why you want this  I d probably put it as a static method in a helper class   public static class Lists       public static List lt T gt  RepeatedDefault lt T gt  int count                return Repeated default T   count              public static List lt T gt  Repeated lt T gt  T value  int count                List lt T gt  ret   new List lt T gt  count           ret AddRange Enumerable Repeat value  count            return ret            You could use Enumerable Repeat default T   count  ToList   but that would be inefficient due to buffer resizing   Note that if T is a reference type  it will store count copies of the reference passed for the value parameter - so they will all refer to the same object  That may or may not be what you want  depending on your use case   EDIT  As noted in comments  you could make Repeated use a loop to populate the list if you wanted to  That would be slightly faster too  Personally I find the code using Repeat more descriptive  and suspect that in the real world the performance difference would be irrelevant  but your mileage may vary

User · Answer

This is an old question  but I have two solutions  One is fast and dirty reflection  the other is a solution that actually answers the question  set the size not the capacity  while still being performant  which none of the answers here do   Reflection This is quick and dirty  and should be pretty obvious what the code does  If you want to speed it up  cache the result of GetField  or create a DynamicMethod to do it  public static void SetSize lt T gt  this List lt T gt  l  int newSize    gt      l GetType   GetField  quot  size quot   BindingFlags NonPublic   BindingFlags Instance  SetValue l  10    Obviously a lot of people will be hesitant to put such code into production   ICollection lt T gt  This solution is based around the fact that the constructor List IEnumerable lt T gt  collection  optimizes for ICollection lt T gt  and immediately adjusts the size to the correct amount  without iterating it  It then calls the collections CopyTo to do the copy  The code is as follows  public List IEnumerable lt T gt  collection             ICollection lt T gt  c   collection as ICollection lt T gt       if  collection is ICollection lt T gt  c                int count   c Count          if  count    0                         items   s emptyArray                    else                items   new T count               c CopyTo  items  0                size   count                       So we can completely optimally pre-initialize the List to the correct size  without any extra copying  How so  By creating an ICollection lt T gt  object that does nothing other than return a Count  Specifically  we will not implement anything in CopyTo which is the only other function called  private class SizeCollection lt T gt    ICollection lt T gt        public SizeCollection int size    gt          Count   size       public void Add T i        public void Clear         public bool Contains T i   gt true      public void CopyTo T  a  int i        public bool Remove T i   gt true      public int Count  get       public bool IsReadOnly  gt true      public IEnumerator lt T gt  GetEnumerator    gt null      IEnumerator IEnumerable GetEnumerator    gt null     public List lt T gt  InitializedList lt T gt  int size    gt      new List lt T gt  new SizeCollection lt T gt  size     We could in theory do the same thing for AddRange InsertRange for an existing array  which also accounts for ICollection lt T gt   but the code there creates a new array for the supposed items  then copies them in  In such case  it would be faster to just empty-loop Add  public void SetSize lt T gt  this List lt T gt  l  int size        if size  lt  l Count          l RemoveRange size  l Count - size       else         for size -  l Count  size  gt  0  size--              l Add default T

User · Answer

List lt string gt  L   new List lt string gt    new string 10

[c#] How to initialize a List<T> to a given size (as opposed to capacity)?

Examples related to c#

Examples related to .net

Examples related to generics

Examples related to list

Examples related to initialization