Best way to combine two or more byte arrays in C

Question

I have 3 byte arrays in C  that I need to combine into one  What would be the most efficient method to complete this task

User · Answer

If you simply need a new byte array  then use the following   byte   Combine byte   a1  byte   a2  byte   a3        byte   ret   new byte a1 Length   a2 Length   a3 Length       Array Copy a1  0  ret  0  a1 Length       Array Copy a2  0  ret  a1 Length  a2 Length       Array Copy a3  0  ret  a1 Length   a2 Length  a3 Length       return ret      Alternatively  if you just need a single IEnumerable  consider using the C  2 0 yield operator   IEnumerable lt byte gt  Combine byte   a1  byte   a2  byte   a3        foreach  byte b in a1          yield return b      foreach  byte b in a2          yield return b      foreach  byte b in a3          yield return b

User · Answer

lt summary gt          Combine two Arrays with offset and count          lt  summary gt           lt param name  src1  gt  lt  param gt           lt param name  offset1  gt  lt  param gt           lt param name  count1  gt  lt  param gt           lt param name  src2  gt  lt  param gt           lt param name  offset2  gt  lt  param gt           lt param name  count2  gt  lt  param gt           lt returns gt  lt  returns gt      public static T   Combine lt T gt  this T   src1  int offset1  int count1  T   src2  int offset2  int count2             gt  Enumerable Range 0  count1   count2  Select a   gt   a  lt  count1    src1 offset1   a    src2 offset2   a - count1   ToArray

User · Answer

For primitive types  including bytes   use System Buffer BlockCopy instead of System Array Copy  It s faster   I timed each of the suggested methods in a loop executed 1 million times using 3 arrays of 10 bytes each  Here are the results    New Byte Array using System Array Copy        - 0 2187556 seconds New Byte Array using System Buffer BlockCopy  - 0 1406286 seconds IEnumerable lt byte  using C  yield operator    - 0 0781270 seconds IEnumerable lt byte  using LINQ s Concat lt        - 0 0781270 seconds   I increased the size of each array to 100 elements and re-ran the test    New Byte Array using System Array Copy        - 0 2812554 seconds New Byte Array using System Buffer BlockCopy  - 0 2500048 seconds IEnumerable lt byte  using C  yield operator    - 0 0625012 seconds IEnumerable lt byte  using LINQ s Concat lt        - 0 0781265 seconds   I increased the size of each array to 1000 elements and re-ran the test    New Byte Array using System Array Copy        - 1 0781457 seconds New Byte Array using System Buffer BlockCopy  - 1 0156445 seconds IEnumerable lt byte  using C  yield operator    - 0 0625012 seconds IEnumerable lt byte  using LINQ s Concat lt        - 0 0781265 seconds   Finally  I increased the size of each array to 1 million elements and re-ran the test  executing each loop only 4000 times    New Byte Array using System Array Copy        - 13 4533833 seconds New Byte Array using System Buffer BlockCopy  - 13 1096267 seconds IEnumerable lt byte  using C  yield operator    - 0 seconds IEnumerable lt byte  using LINQ s Concat lt        - 0 seconds   So  if you need a new byte array  use  byte   rv   new byte a1 Length   a2 Length   a3 Length   System Buffer BlockCopy a1  0  rv  0  a1 Length   System Buffer BlockCopy a2  0  rv  a1 Length  a2 Length   System Buffer BlockCopy a3  0  rv  a1 Length   a2 Length  a3 Length     But  if you can use an IEnumerable lt byte gt   DEFINITELY prefer LINQ s Concat lt   method  It s only slightly slower than the C  yield operator  but is more concise and more elegant   IEnumerable lt byte gt  rv   a1 Concat a2  Concat a3     If you have an arbitrary number of arrays and are using  NET 3 5  you can make the System Buffer BlockCopy solution more generic like this   private byte   Combine params byte     arrays        byte   rv   new byte arrays Sum a   gt  a Length        int offset   0      foreach  byte   array in arrays            System Buffer BlockCopy array  0  rv  offset  array Length           offset    array Length            return rv       Note  The above block requires you adding the following namespace at the the top for it to work   using System Linq    To Jon Skeet s point regarding iteration of the subsequent data structures  byte array vs  IEnumerable lt byte    I re-ran the last timing test  1 million elements  4000 iterations   adding a loop that iterates over the full array with each pass    New Byte Array using System Array Copy        -  78 20550510 seconds New Byte Array using System Buffer BlockCopy  -  77 89261900 seconds IEnumerable lt byte  using C  yield operator    - 551 7150161  seconds IEnumerable lt byte  using LINQ s Concat lt        - 448 1804799  seconds   The point is  it is VERY important to understand the efficiency of both the creation and the usage of the resulting data structure  Simply focusing on the efficiency of the creation may overlook the inefficiency associated with the usage  Kudos  Jon

User · Answer

Many of the answers seem to me to be ignoring the stated requirements    The result should be a byte array It should be as efficient as possible   These two together rule out a LINQ sequence of bytes - anything with yield is going to make it impossible to get the final size without iterating through the whole sequence   If those aren t the real requirements of course  LINQ could be a perfectly good solution  or the IList lt T gt  implementation   However  I ll assume that Superdumbell knows what he wants    EDIT  I ve just had another thought  There s a big semantic difference between making a copy of the arrays and reading them lazily  Consider what happens if you change the data in one of the  source  arrays after calling the Combine  or whatever  method but before using the result - with lazy evaluation  that change will be visible  With an immediate copy  it won t  Different situations will call for different behaviour - just something to be aware of    Here are my proposed methods - which are very similar to those contained in some of the other answers  certainly     public static byte   Combine byte   first  byte   second        byte   ret   new byte first Length   second Length       Buffer BlockCopy first  0  ret  0  first Length       Buffer BlockCopy second  0  ret  first Length  second Length       return ret     public static byte   Combine byte   first  byte   second  byte   third        byte   ret   new byte first Length   second Length   third Length       Buffer BlockCopy first  0  ret  0  first Length       Buffer BlockCopy second  0  ret  first Length  second Length       Buffer BlockCopy third  0  ret  first Length   second Length                       third Length       return ret     public static byte   Combine params byte     arrays        byte   ret   new byte arrays Sum x   gt  x Length        int offset   0      foreach  byte   data in arrays                Buffer BlockCopy data  0  ret  offset  data Length           offset    data Length            return ret      Of course the  params  version requires creating an array of the byte arrays first  which introduces extra inefficiency

User · Answer

I actually ran into some issues with using Concat     with arrays in the 10-million  it actually crashed    I found the following to be simple  easy and works well enough without crashing on me  and it works for ANY number of arrays  not just three   It uses LINQ    public static byte   ConcatByteArrays params byte      arrays        return arrays SelectMany x   gt  x  ToArray

User · Answer

Many of the answers seem to me to be ignoring the stated requirements    The result should be a byte array It should be as efficient as possible   These two together rule out a LINQ sequence of bytes - anything with yield is going to make it impossible to get the final size without iterating through the whole sequence   If those aren t the real requirements of course  LINQ could be a perfectly good solution  or the IList lt T gt  implementation   However  I ll assume that Superdumbell knows what he wants    EDIT  I ve just had another thought  There s a big semantic difference between making a copy of the arrays and reading them lazily  Consider what happens if you change the data in one of the  source  arrays after calling the Combine  or whatever  method but before using the result - with lazy evaluation  that change will be visible  With an immediate copy  it won t  Different situations will call for different behaviour - just something to be aware of    Here are my proposed methods - which are very similar to those contained in some of the other answers  certainly     public static byte   Combine byte   first  byte   second        byte   ret   new byte first Length   second Length       Buffer BlockCopy first  0  ret  0  first Length       Buffer BlockCopy second  0  ret  first Length  second Length       return ret     public static byte   Combine byte   first  byte   second  byte   third        byte   ret   new byte first Length   second Length   third Length       Buffer BlockCopy first  0  ret  0  first Length       Buffer BlockCopy second  0  ret  first Length  second Length       Buffer BlockCopy third  0  ret  first Length   second Length                       third Length       return ret     public static byte   Combine params byte     arrays        byte   ret   new byte arrays Sum x   gt  x Length        int offset   0      foreach  byte   data in arrays                Buffer BlockCopy data  0  ret  offset  data Length           offset    data Length            return ret      Of course the  params  version requires creating an array of the byte arrays first  which introduces extra inefficiency

User · Answer

I actually ran into some issues with using Concat     with arrays in the 10-million  it actually crashed    I found the following to be simple  easy and works well enough without crashing on me  and it works for ANY number of arrays  not just three   It uses LINQ    public static byte   ConcatByteArrays params byte      arrays        return arrays SelectMany x   gt  x  ToArray

User · Answer

All you need to pass list of Byte Arrays and this function will return you the Array of Bytes  Merged   This is the best solution i think      public static byte   CombineMultipleByteArrays List lt byte   gt  lstByteArray                        using  var ms   new MemoryStream                                  using  var doc   new iTextSharp text Document                                          using  var copy   new PdfSmartCopy doc  ms                                                 doc Open                            foreach  var p in lstByteArray                                                        using  var reader   new PdfReader p                                                                 copy AddDocument reader                                                                                    doc Close                                                            return ms ToArray

User · Answer

Concat is the right answer  but for some reason a handrolled thing is getting the most votes   If you like that answer  perhaps you d like this more general solution even more       IEnumerable lt byte gt  Combine params byte     arrays                foreach  byte   a in arrays              foreach  byte b in a                  yield return b          which would let you do things like       byte   c   Combine new byte     0  1  2    new byte     3  4  5    ToArray

User · Answer

The memorystream class does this job pretty nicely for me   I couldn t get the buffer class to run as fast as memorystream   using  MemoryStream ms   new MemoryStream        ms Write BitConverter GetBytes 22  0 4     ms Write BitConverter GetBytes 44  0 4     ms ToArray

User · Answer

For primitive types  including bytes   use System Buffer BlockCopy instead of System Array Copy  It s faster   I timed each of the suggested methods in a loop executed 1 million times using 3 arrays of 10 bytes each  Here are the results    New Byte Array using System Array Copy        - 0 2187556 seconds New Byte Array using System Buffer BlockCopy  - 0 1406286 seconds IEnumerable lt byte  using C  yield operator    - 0 0781270 seconds IEnumerable lt byte  using LINQ s Concat lt        - 0 0781270 seconds   I increased the size of each array to 100 elements and re-ran the test    New Byte Array using System Array Copy        - 0 2812554 seconds New Byte Array using System Buffer BlockCopy  - 0 2500048 seconds IEnumerable lt byte  using C  yield operator    - 0 0625012 seconds IEnumerable lt byte  using LINQ s Concat lt        - 0 0781265 seconds   I increased the size of each array to 1000 elements and re-ran the test    New Byte Array using System Array Copy        - 1 0781457 seconds New Byte Array using System Buffer BlockCopy  - 1 0156445 seconds IEnumerable lt byte  using C  yield operator    - 0 0625012 seconds IEnumerable lt byte  using LINQ s Concat lt        - 0 0781265 seconds   Finally  I increased the size of each array to 1 million elements and re-ran the test  executing each loop only 4000 times    New Byte Array using System Array Copy        - 13 4533833 seconds New Byte Array using System Buffer BlockCopy  - 13 1096267 seconds IEnumerable lt byte  using C  yield operator    - 0 seconds IEnumerable lt byte  using LINQ s Concat lt        - 0 seconds   So  if you need a new byte array  use  byte   rv   new byte a1 Length   a2 Length   a3 Length   System Buffer BlockCopy a1  0  rv  0  a1 Length   System Buffer BlockCopy a2  0  rv  a1 Length  a2 Length   System Buffer BlockCopy a3  0  rv  a1 Length   a2 Length  a3 Length     But  if you can use an IEnumerable lt byte gt   DEFINITELY prefer LINQ s Concat lt   method  It s only slightly slower than the C  yield operator  but is more concise and more elegant   IEnumerable lt byte gt  rv   a1 Concat a2  Concat a3     If you have an arbitrary number of arrays and are using  NET 3 5  you can make the System Buffer BlockCopy solution more generic like this   private byte   Combine params byte     arrays        byte   rv   new byte arrays Sum a   gt  a Length        int offset   0      foreach  byte   array in arrays            System Buffer BlockCopy array  0  rv  offset  array Length           offset    array Length            return rv       Note  The above block requires you adding the following namespace at the the top for it to work   using System Linq    To Jon Skeet s point regarding iteration of the subsequent data structures  byte array vs  IEnumerable lt byte    I re-ran the last timing test  1 million elements  4000 iterations   adding a loop that iterates over the full array with each pass    New Byte Array using System Array Copy        -  78 20550510 seconds New Byte Array using System Buffer BlockCopy  -  77 89261900 seconds IEnumerable lt byte  using C  yield operator    - 551 7150161  seconds IEnumerable lt byte  using LINQ s Concat lt        - 448 1804799  seconds   The point is  it is VERY important to understand the efficiency of both the creation and the usage of the resulting data structure  Simply focusing on the efficiency of the creation may overlook the inefficiency associated with the usage  Kudos  Jon

User · Answer

lt summary gt          Combine two Arrays with offset and count          lt  summary gt           lt param name  src1  gt  lt  param gt           lt param name  offset1  gt  lt  param gt           lt param name  count1  gt  lt  param gt           lt param name  src2  gt  lt  param gt           lt param name  offset2  gt  lt  param gt           lt param name  count2  gt  lt  param gt           lt returns gt  lt  returns gt      public static T   Combine lt T gt  this T   src1  int offset1  int count1  T   src2  int offset2  int count2             gt  Enumerable Range 0  count1   count2  Select a   gt   a  lt  count1    src1 offset1   a    src2 offset2   a - count1   ToArray

User · Answer

Here s a generalization of the answer provided by  Jon Skeet  It is basically the same  only it is usable for any type of array  not only bytes   public static T   Combine lt T gt  T   first  T   second        T   ret   new T first Length   second Length       Buffer BlockCopy first  0  ret  0  first Length       Buffer BlockCopy second  0  ret  first Length  second Length       return ret     public static T   Combine lt T gt  T   first  T   second  T   third        T   ret   new T first Length   second Length   third Length       Buffer BlockCopy first  0  ret  0  first Length       Buffer BlockCopy second  0  ret  first Length  second Length       Buffer BlockCopy third  0  ret  first Length   second Length                       third Length       return ret     public static T   Combine lt T gt  params T     arrays        T   ret   new T arrays Sum x   gt  x Length        int offset   0      foreach  T   data in arrays                Buffer BlockCopy data  0  ret  offset  data Length           offset    data Length            return ret

User · Answer

Many of the answers seem to me to be ignoring the stated requirements    The result should be a byte array It should be as efficient as possible   These two together rule out a LINQ sequence of bytes - anything with yield is going to make it impossible to get the final size without iterating through the whole sequence   If those aren t the real requirements of course  LINQ could be a perfectly good solution  or the IList lt T gt  implementation   However  I ll assume that Superdumbell knows what he wants    EDIT  I ve just had another thought  There s a big semantic difference between making a copy of the arrays and reading them lazily  Consider what happens if you change the data in one of the  source  arrays after calling the Combine  or whatever  method but before using the result - with lazy evaluation  that change will be visible  With an immediate copy  it won t  Different situations will call for different behaviour - just something to be aware of    Here are my proposed methods - which are very similar to those contained in some of the other answers  certainly     public static byte   Combine byte   first  byte   second        byte   ret   new byte first Length   second Length       Buffer BlockCopy first  0  ret  0  first Length       Buffer BlockCopy second  0  ret  first Length  second Length       return ret     public static byte   Combine byte   first  byte   second  byte   third        byte   ret   new byte first Length   second Length   third Length       Buffer BlockCopy first  0  ret  0  first Length       Buffer BlockCopy second  0  ret  first Length  second Length       Buffer BlockCopy third  0  ret  first Length   second Length                       third Length       return ret     public static byte   Combine params byte     arrays        byte   ret   new byte arrays Sum x   gt  x Length        int offset   0      foreach  byte   data in arrays                Buffer BlockCopy data  0  ret  offset  data Length           offset    data Length            return ret      Of course the  params  version requires creating an array of the byte arrays first  which introduces extra inefficiency

User · Answer

Here s a generalization of the answer provided by  Jon Skeet  It is basically the same  only it is usable for any type of array  not only bytes   public static T   Combine lt T gt  T   first  T   second        T   ret   new T first Length   second Length       Buffer BlockCopy first  0  ret  0  first Length       Buffer BlockCopy second  0  ret  first Length  second Length       return ret     public static T   Combine lt T gt  T   first  T   second  T   third        T   ret   new T first Length   second Length   third Length       Buffer BlockCopy first  0  ret  0  first Length       Buffer BlockCopy second  0  ret  first Length  second Length       Buffer BlockCopy third  0  ret  first Length   second Length                       third Length       return ret     public static T   Combine lt T gt  params T     arrays        T   ret   new T arrays Sum x   gt  x Length        int offset   0      foreach  T   data in arrays                Buffer BlockCopy data  0  ret  offset  data Length           offset    data Length            return ret

User · Answer

public static byte   Concat params byte     arrays            using  var mem   new MemoryStream arrays Sum a   gt  a Length                  foreach  var array in arrays                    mem Write array  0  array Length                             return mem ToArray

User · Answer

public static bool MyConcat lt T gt  ref T   base arr  ref T   add arr                try                       int base size   base arr Length              int size T   System Runtime InteropServices Marshal SizeOf base arr 0                Array Resize ref base arr  base size   add arr Length               Buffer BlockCopy add arr  0  base arr  base size   size T  add arr Length   size T                     catch  IndexOutOfRangeException ioor                        MessageBox Show ioor Message               return false                    return true

User · Answer

For primitive types  including bytes   use System Buffer BlockCopy instead of System Array Copy  It s faster   I timed each of the suggested methods in a loop executed 1 million times using 3 arrays of 10 bytes each  Here are the results    New Byte Array using System Array Copy        - 0 2187556 seconds New Byte Array using System Buffer BlockCopy  - 0 1406286 seconds IEnumerable lt byte  using C  yield operator    - 0 0781270 seconds IEnumerable lt byte  using LINQ s Concat lt        - 0 0781270 seconds   I increased the size of each array to 100 elements and re-ran the test    New Byte Array using System Array Copy        - 0 2812554 seconds New Byte Array using System Buffer BlockCopy  - 0 2500048 seconds IEnumerable lt byte  using C  yield operator    - 0 0625012 seconds IEnumerable lt byte  using LINQ s Concat lt        - 0 0781265 seconds   I increased the size of each array to 1000 elements and re-ran the test    New Byte Array using System Array Copy        - 1 0781457 seconds New Byte Array using System Buffer BlockCopy  - 1 0156445 seconds IEnumerable lt byte  using C  yield operator    - 0 0625012 seconds IEnumerable lt byte  using LINQ s Concat lt        - 0 0781265 seconds   Finally  I increased the size of each array to 1 million elements and re-ran the test  executing each loop only 4000 times    New Byte Array using System Array Copy        - 13 4533833 seconds New Byte Array using System Buffer BlockCopy  - 13 1096267 seconds IEnumerable lt byte  using C  yield operator    - 0 seconds IEnumerable lt byte  using LINQ s Concat lt        - 0 seconds   So  if you need a new byte array  use  byte   rv   new byte a1 Length   a2 Length   a3 Length   System Buffer BlockCopy a1  0  rv  0  a1 Length   System Buffer BlockCopy a2  0  rv  a1 Length  a2 Length   System Buffer BlockCopy a3  0  rv  a1 Length   a2 Length  a3 Length     But  if you can use an IEnumerable lt byte gt   DEFINITELY prefer LINQ s Concat lt   method  It s only slightly slower than the C  yield operator  but is more concise and more elegant   IEnumerable lt byte gt  rv   a1 Concat a2  Concat a3     If you have an arbitrary number of arrays and are using  NET 3 5  you can make the System Buffer BlockCopy solution more generic like this   private byte   Combine params byte     arrays        byte   rv   new byte arrays Sum a   gt  a Length        int offset   0      foreach  byte   array in arrays            System Buffer BlockCopy array  0  rv  offset  array Length           offset    array Length            return rv       Note  The above block requires you adding the following namespace at the the top for it to work   using System Linq    To Jon Skeet s point regarding iteration of the subsequent data structures  byte array vs  IEnumerable lt byte    I re-ran the last timing test  1 million elements  4000 iterations   adding a loop that iterates over the full array with each pass    New Byte Array using System Array Copy        -  78 20550510 seconds New Byte Array using System Buffer BlockCopy  -  77 89261900 seconds IEnumerable lt byte  using C  yield operator    - 551 7150161  seconds IEnumerable lt byte  using LINQ s Concat lt        - 448 1804799  seconds   The point is  it is VERY important to understand the efficiency of both the creation and the usage of the resulting data structure  Simply focusing on the efficiency of the creation may overlook the inefficiency associated with the usage  Kudos  Jon

User · Answer

I took Matt s LINQ example one step further for code cleanliness   byte   rv   a1 Concat a2  Concat a3  ToArray      In my case  the arrays are small  so I m not concerned about performance

User · Answer

Concat is the right answer  but for some reason a handrolled thing is getting the most votes   If you like that answer  perhaps you d like this more general solution even more       IEnumerable lt byte gt  Combine params byte     arrays                foreach  byte   a in arrays              foreach  byte b in a                  yield return b          which would let you do things like       byte   c   Combine new byte     0  1  2    new byte     3  4  5    ToArray

User · Answer

public static byte   Concat params byte     arrays            using  var mem   new MemoryStream arrays Sum a   gt  a Length                  foreach  var array in arrays                    mem Write array  0  array Length                             return mem ToArray

User · Answer

Can use generics to combine arrays  Following code can easily be expanded to three arrays   This way you never need to duplicate code for different type of arrays   Some of the above answers seem overly complex to me   private static T   CombineTwoArrays lt T gt  T   a1  T   a2                T   arrayCombined   new T a1 Length   a2 Length           Array Copy a1  0  arrayCombined  0  a1 Length           Array Copy a2  0  arrayCombined  a1 Length  a2 Length           return arrayCombined

User · Answer

If you simply need a new byte array  then use the following   byte   Combine byte   a1  byte   a2  byte   a3        byte   ret   new byte a1 Length   a2 Length   a3 Length       Array Copy a1  0  ret  0  a1 Length       Array Copy a2  0  ret  a1 Length  a2 Length       Array Copy a3  0  ret  a1 Length   a2 Length  a3 Length       return ret      Alternatively  if you just need a single IEnumerable  consider using the C  2 0 yield operator   IEnumerable lt byte gt  Combine byte   a1  byte   a2  byte   a3        foreach  byte b in a1          yield return b      foreach  byte b in a2          yield return b      foreach  byte b in a3          yield return b

User · Answer

For primitive types  including bytes   use System Buffer BlockCopy instead of System Array Copy  It s faster   I timed each of the suggested methods in a loop executed 1 million times using 3 arrays of 10 bytes each  Here are the results    New Byte Array using System Array Copy        - 0 2187556 seconds New Byte Array using System Buffer BlockCopy  - 0 1406286 seconds IEnumerable lt byte  using C  yield operator    - 0 0781270 seconds IEnumerable lt byte  using LINQ s Concat lt        - 0 0781270 seconds   I increased the size of each array to 100 elements and re-ran the test    New Byte Array using System Array Copy        - 0 2812554 seconds New Byte Array using System Buffer BlockCopy  - 0 2500048 seconds IEnumerable lt byte  using C  yield operator    - 0 0625012 seconds IEnumerable lt byte  using LINQ s Concat lt        - 0 0781265 seconds   I increased the size of each array to 1000 elements and re-ran the test    New Byte Array using System Array Copy        - 1 0781457 seconds New Byte Array using System Buffer BlockCopy  - 1 0156445 seconds IEnumerable lt byte  using C  yield operator    - 0 0625012 seconds IEnumerable lt byte  using LINQ s Concat lt        - 0 0781265 seconds   Finally  I increased the size of each array to 1 million elements and re-ran the test  executing each loop only 4000 times    New Byte Array using System Array Copy        - 13 4533833 seconds New Byte Array using System Buffer BlockCopy  - 13 1096267 seconds IEnumerable lt byte  using C  yield operator    - 0 seconds IEnumerable lt byte  using LINQ s Concat lt        - 0 seconds   So  if you need a new byte array  use  byte   rv   new byte a1 Length   a2 Length   a3 Length   System Buffer BlockCopy a1  0  rv  0  a1 Length   System Buffer BlockCopy a2  0  rv  a1 Length  a2 Length   System Buffer BlockCopy a3  0  rv  a1 Length   a2 Length  a3 Length     But  if you can use an IEnumerable lt byte gt   DEFINITELY prefer LINQ s Concat lt   method  It s only slightly slower than the C  yield operator  but is more concise and more elegant   IEnumerable lt byte gt  rv   a1 Concat a2  Concat a3     If you have an arbitrary number of arrays and are using  NET 3 5  you can make the System Buffer BlockCopy solution more generic like this   private byte   Combine params byte     arrays        byte   rv   new byte arrays Sum a   gt  a Length        int offset   0      foreach  byte   array in arrays            System Buffer BlockCopy array  0  rv  offset  array Length           offset    array Length            return rv       Note  The above block requires you adding the following namespace at the the top for it to work   using System Linq    To Jon Skeet s point regarding iteration of the subsequent data structures  byte array vs  IEnumerable lt byte    I re-ran the last timing test  1 million elements  4000 iterations   adding a loop that iterates over the full array with each pass    New Byte Array using System Array Copy        -  78 20550510 seconds New Byte Array using System Buffer BlockCopy  -  77 89261900 seconds IEnumerable lt byte  using C  yield operator    - 551 7150161  seconds IEnumerable lt byte  using LINQ s Concat lt        - 448 1804799  seconds   The point is  it is VERY important to understand the efficiency of both the creation and the usage of the resulting data structure  Simply focusing on the efficiency of the creation may overlook the inefficiency associated with the usage  Kudos  Jon

User · Answer

Can use generics to combine arrays  Following code can easily be expanded to three arrays   This way you never need to duplicate code for different type of arrays   Some of the above answers seem overly complex to me   private static T   CombineTwoArrays lt T gt  T   a1  T   a2                T   arrayCombined   new T a1 Length   a2 Length           Array Copy a1  0  arrayCombined  0  a1 Length           Array Copy a2  0  arrayCombined  a1 Length  a2 Length           return arrayCombined

User · Answer

Many of the answers seem to me to be ignoring the stated requirements    The result should be a byte array It should be as efficient as possible   These two together rule out a LINQ sequence of bytes - anything with yield is going to make it impossible to get the final size without iterating through the whole sequence   If those aren t the real requirements of course  LINQ could be a perfectly good solution  or the IList lt T gt  implementation   However  I ll assume that Superdumbell knows what he wants    EDIT  I ve just had another thought  There s a big semantic difference between making a copy of the arrays and reading them lazily  Consider what happens if you change the data in one of the  source  arrays after calling the Combine  or whatever  method but before using the result - with lazy evaluation  that change will be visible  With an immediate copy  it won t  Different situations will call for different behaviour - just something to be aware of    Here are my proposed methods - which are very similar to those contained in some of the other answers  certainly     public static byte   Combine byte   first  byte   second        byte   ret   new byte first Length   second Length       Buffer BlockCopy first  0  ret  0  first Length       Buffer BlockCopy second  0  ret  first Length  second Length       return ret     public static byte   Combine byte   first  byte   second  byte   third        byte   ret   new byte first Length   second Length   third Length       Buffer BlockCopy first  0  ret  0  first Length       Buffer BlockCopy second  0  ret  first Length  second Length       Buffer BlockCopy third  0  ret  first Length   second Length                       third Length       return ret     public static byte   Combine params byte     arrays        byte   ret   new byte arrays Sum x   gt  x Length        int offset   0      foreach  byte   data in arrays                Buffer BlockCopy data  0  ret  offset  data Length           offset    data Length            return ret      Of course the  params  version requires creating an array of the byte arrays first  which introduces extra inefficiency

User · Answer

If you simply need a new byte array  then use the following   byte   Combine byte   a1  byte   a2  byte   a3        byte   ret   new byte a1 Length   a2 Length   a3 Length       Array Copy a1  0  ret  0  a1 Length       Array Copy a2  0  ret  a1 Length  a2 Length       Array Copy a3  0  ret  a1 Length   a2 Length  a3 Length       return ret      Alternatively  if you just need a single IEnumerable  consider using the C  2 0 yield operator   IEnumerable lt byte gt  Combine byte   a1  byte   a2  byte   a3        foreach  byte b in a1          yield return b      foreach  byte b in a2          yield return b      foreach  byte b in a3          yield return b

User · Answer

All you need to pass list of Byte Arrays and this function will return you the Array of Bytes  Merged   This is the best solution i think      public static byte   CombineMultipleByteArrays List lt byte   gt  lstByteArray                        using  var ms   new MemoryStream                                  using  var doc   new iTextSharp text Document                                          using  var copy   new PdfSmartCopy doc  ms                                                 doc Open                            foreach  var p in lstByteArray                                                        using  var reader   new PdfReader p                                                                 copy AddDocument reader                                                                                    doc Close                                                            return ms ToArray

User · Answer

If you simply need a new byte array  then use the following   byte   Combine byte   a1  byte   a2  byte   a3        byte   ret   new byte a1 Length   a2 Length   a3 Length       Array Copy a1  0  ret  0  a1 Length       Array Copy a2  0  ret  a1 Length  a2 Length       Array Copy a3  0  ret  a1 Length   a2 Length  a3 Length       return ret      Alternatively  if you just need a single IEnumerable  consider using the C  2 0 yield operator   IEnumerable lt byte gt  Combine byte   a1  byte   a2  byte   a3        foreach  byte b in a1          yield return b      foreach  byte b in a2          yield return b      foreach  byte b in a3          yield return b

User · Answer

I took Matt s LINQ example one step further for code cleanliness   byte   rv   a1 Concat a2  Concat a3  ToArray      In my case  the arrays are small  so I m not concerned about performance

User · Answer

public static bool MyConcat lt T gt  ref T   base arr  ref T   add arr                try                       int base size   base arr Length              int size T   System Runtime InteropServices Marshal SizeOf base arr 0                Array Resize ref base arr  base size   add arr Length               Buffer BlockCopy add arr  0  base arr  base size   size T  add arr Length   size T                     catch  IndexOutOfRangeException ioor                        MessageBox Show ioor Message               return false                    return true

User · Answer

The memorystream class does this job pretty nicely for me   I couldn t get the buffer class to run as fast as memorystream   using  MemoryStream ms   new MemoryStream        ms Write BitConverter GetBytes 22  0 4     ms Write BitConverter GetBytes 44  0 4     ms ToArray

User · Answer

Concat is the right answer  but for some reason a handrolled thing is getting the most votes   If you like that answer  perhaps you d like this more general solution even more       IEnumerable lt byte gt  Combine params byte     arrays                foreach  byte   a in arrays              foreach  byte b in a                  yield return b          which would let you do things like       byte   c   Combine new byte     0  1  2    new byte     3  4  5    ToArray

User · Answer

Concat is the right answer  but for some reason a handrolled thing is getting the most votes   If you like that answer  perhaps you d like this more general solution even more       IEnumerable lt byte gt  Combine params byte     arrays                foreach  byte   a in arrays              foreach  byte b in a                  yield return b          which would let you do things like       byte   c   Combine new byte     0  1  2    new byte     3  4  5    ToArray

[c#] Best way to combine two or more byte arrays in C#

Examples related to c#

Examples related to arrays