Initialize a byte array to a certain value other than the default null

Question

I m busy rewriting an old project that was done in C    to C     My task is to rewrite the program so that it functions as close to the original as possible   During a bunch of file-handling the previous developer who wrote this program creates a structure containing a ton of fields that correspond to the set format that a file has to be written in  so all that work is already done for me    These fields are all byte arrays  What the C   code then does is use memset to set this entire structure to all spaces characters  0x20   One line of code  Easy   This is very important as the utility that this file eventually goes to is expecting the file in this format  What I ve had to do is change this struct to a class in C   but I cannot find a way to easily initialize each of these byte arrays to all space characters   What I ve ended up having to do is this in the class constructor     Initialize all of the variables to spaces  int index   0  foreach  byte b in UserCode        UserCode index    0x20      index        This works fine  but I m sure there must be a simpler way to do this  When the array is set to UserCode   new byte 6  in the constructor the byte array gets automatically initialized to the default null values  Is there no way that I can make it become all spaces upon declaration  so that when I call my class  constructor that it is initialized straight away like this  Or some memset-like function

User · Answer

You could speed up the initialization and simplify the code by using the the Parallel class (.NET 4 and newer):

public static void PopulateByteArray(byte[] byteArray, byte value)
{
    Parallel.For(0, byteArray.Length, i => byteArray[i] = value);
}

Of course you can create the array at the same time:

public static byte[] CreateSpecialByteArray(int length, byte value)
{
    var byteArray = new byte[length];
    Parallel.For(0, length, i => byteArray[i] = value);
    return byteArray;
}

User · Answer

You can use Enumerable Repeat       Enumerable Repeat generates a sequence that contains one repeated value    Array of 100 items initialized to 0x20   byte   arr1   Enumerable Repeat  byte 0x20 100  ToArray

User · Answer

Just to expand on my answer a neater way of doing this multiple times would probably be   PopulateByteArray UserCode  0x20     which calls   public static void PopulateByteArray byte   byteArray  byte value        for  int i   0  i  lt  byteArray Length  i                  byteArray i    value            This has the advantage of a nice efficient for loop  mention to gwiazdorrr s answer  as well as a nice neat looking call if it is being used a lot  And a lot mroe at a glance readable than the enumeration one I personally think

User · Answer

Maybe these could be helpful   What is the equivalent of memset in C    http   techmikael blogspot com 2009 12 filling-array-with-default-value html

User · Answer

You can use a collection initializer   UserCode   new byte   0x20 0x20 0x20 0x20 0x20 0x20     This will work better than Repeat if the values are not identical

User · Answer

This is a faster version of the code from the post marked as the answer   All of the benchmarks that I have performed show that a simple for loop that only contains something like an array fill is typically twice as fast if it is decrementing versus if it is incrementing   Also  the array Length property is already passed as the parameter so it doesn t need to be retrieved from the array properties   It should also be pre-calculated and assigned to a local variable  Loop bounds calculations that involve a property accessor will re-compute the value of the bounds before each iteration of the loop   public static byte   CreateSpecialByteArray int length        byte   array   new byte length        int len   length - 1       for  int i   len  i  gt   0  i--                array i    0x20             return array

User · Answer

var array   Encoding ASCII GetBytes new string      100

User · Answer

If you need to initialise a small array you can use  byte   smallArray   new byte     0x20  0x20  0x20  0x20  0x20  0x20  0x20     If you have a larger array  then you could use  byte   bitBiggerArray Enumerable Repeat 0x20  7000  ToArray     Which is simple  and easy for the next guy girl to read  And will be fast enough 99 9  of the time   Normally will be the BestOption     However if you really really need super speed  calling out to the optimized memset method  using P invoke  is for you   Here wrapped up in a nice to use class  public static class Superfast        DllImport  quot msvcrt dll quot                 EntryPoint    quot memset quot                 CallingConvention   CallingConvention Cdecl                SetLastError   false       private static extern IntPtr MemSet IntPtr dest  int c  int count          If you need super speed  calling out to M  memset optimized method using P invoke     public static byte   InitByteArray byte fillWith  int size                byte   arrayBytes   new byte size           GCHandle gch   GCHandle Alloc arrayBytes  GCHandleType Pinned           MemSet gch AddrOfPinnedObject    fillWith  arrayBytes Length           gch Free            return arrayBytes           Usage  byte   oneofManyBigArrays    Superfast InitByteArray 0x20 700000

User · Answer

This function is way faster than a for loop for filling an array     The Array Copy command is a very fast memory copy function   This function takes advantage of that by repeatedly calling the Array Copy command and doubling the size of what we copy until the array is full   I discuss this on my blog at https   grax32 com 2013 06 fast-array-fill-function-revisited html  Link updated 12 16 2019    Also see Nuget package that provides this extension method   http   sites grax32 com ArrayExtensions   Note that this would be easy to make into an extension method by just adding the word  this  to the method declarations i e  public static void ArrayFill lt T gt  this T   arrayToFill      public static void ArrayFill lt T gt  T   arrayToFill  T fillValue           if called with a single value  wrap the value in an array and call the main function     ArrayFill arrayToFill  new T     fillValue        public static void ArrayFill lt T gt  T   arrayToFill  T   fillValue        if  fillValue Length  gt   arrayToFill Length                throw new ArgumentException  fillValue array length must be smaller than length of arrayToFill                  set the initial array value     Array Copy fillValue  arrayToFill  fillValue Length        int arrayToFillHalfLength   arrayToFill Length   2       for  int i   fillValue Length  i  lt  arrayToFill Length  i    2                int copyLength   i          if  i  gt  arrayToFillHalfLength                        copyLength   arrayToFill Length - i                     Array Copy arrayToFill  0  arrayToFill  i  copyLength

User · Answer

For small arrays use array initialisation syntax   var sevenItems   new byte     0x20  0x20  0x20  0x20  0x20  0x20  0x20      For larger arrays use a standard for loop  This is the most readable and efficient way to do it   var sevenThousandItems   new byte 7000   for  int i   0  i  lt  sevenThousandItems Length  i          sevenThousandItems i    0x20      Of course  if you need to do this a lot then you could create a helper method to help keep your code concise   byte   sevenItems   CreateSpecialByteArray 7   byte   sevenThousandItems   CreateSpecialByteArray 7000            public static byte   CreateSpecialByteArray int length        var arr   new byte length       for  int i   0  i  lt  arr Length  i                  arr i    0x20            return arr

User · Answer

The fastest way to do this is to use the api   bR   0xFF   RtlFillMemory pBuffer  nFileLen  bR    using a pointer to a buffer  the length to write  and the encoded byte  I think the fastest way to do it in managed code  much slower   is to create a small block of initialized bytes  then use Buffer Blockcopy to write them to the byte array in a loop  I threw this together but haven t tested it  but you get the idea   long size   GetFileSize FileName      zero byte const int blocksize   1024     1 s array byte   ntemp   new byte blocksize   byte   nbyte   new byte size      init 1 s array for  int i   0  i  lt  blocksize  i        ntemp i    0xff      get dimensions int blocks    int  size   blocksize   int remainder    int  size -  blocks   blocksize    int count   0      copy to the buffer do       Buffer BlockCopy ntemp  0  nbyte  blocksize   count  blocksize       count      while  count  lt  blocks       copy remaining bytes Buffer BlockCopy ntemp  0  nbyte  blocksize   count  remainder

User · Answer

Guys before me gave you your answer  I just want to point out your misuse of foreach loop  See  since you have to increment index standard  for loop  would be not only more compact  but also more efficient   foreach  does many things under the hood    for  int index   0  index  lt  UserCode Length    index        UserCode index    0x20

User · Answer

Use this to create the array in the first place   byte   array   Enumerable Repeat  byte 0x20   lt number of elements gt   ToArray      Replace  lt number of elements gt  with the desired array size

[c#] Initialize a byte array to a certain value, other than the default null?

Examples related to c#

Examples related to .net

Examples related to arrays

Examples related to initialization