Array slices in C

Question

How do you do it  Given a byte array   byte   foo   new byte 4096     How would I get the first x bytes of the array as a separate array   Specifically  I need it as an IEnumerable lt byte gt    This is for working with Sockets  I figure the easiest way would be array slicing  similar to Perls syntax    bar    foo 0  40     Which would return the first 41 elements into the  bar array  Is there something in C  that I m just missing  or is there some other thing I should be doing   LINQ is an option for me   NET 3 5   if that helps any

User · Answer

You could use the arrays CopyTo   method   Or with LINQ you can use Skip   and Take       byte   arr    1  2  3  4  5  6  7  8   var subset   arr Skip 2  Take 2

User · Answer

static byte   SliceMe byte   source  int length        byte   destfoo   new byte length       Array Copy source  0  destfoo  0  length       return destfoo          var myslice   SliceMe sourcearray 41

User · Answer

Arrays are enumerable  so your foo already is an IEnumerable lt byte gt  itself  Simply use LINQ sequence methods like Take   to get what you want out of it  don t forget to include the Linq namespace with  using System Linq     byte   foo   new byte 4096    var bar   foo Take 41     If you really need an array from any IEnumerable lt byte gt  value  you could use the ToArray   method for that  That does not seem to be the case here

User · Answer

If you don t want to add LINQ or other extensions just do   float   subArray   new List lt float gt  myArray  GetRange 0  8  ToArray

User · Answer

static byte   SliceMe byte   source  int length        byte   destfoo   new byte length       Array Copy source  0  destfoo  0  length       return destfoo          var myslice   SliceMe sourcearray 41

User · Answer

You could use ArraySegment lt T gt   It s very light-weight as it doesn t copy the array   string   a      one    two    three    four    five     var segment   new ArraySegment lt string gt   a  1  2

User · Answer

You could use a wrapper around the original array  which is IList   like in this  untested  piece of code  public class SubList lt T gt    IList lt T gt         region Fields      private readonly int startIndex      private readonly int endIndex      private readonly int count      private readonly IList lt T gt  source        endregion      public SubList IList lt T gt  source  int startIndex  int count                this source   source          this startIndex   startIndex          this count   count          this endIndex   this startIndex   this count - 1              region IList lt T gt  Members      public int IndexOf T item                if  item    null                        for  int i   this startIndex  i  lt   this endIndex  i                                  if  item Equals this source i                        return i                                  else                       for  int i   this startIndex  i  lt   this endIndex  i                                  if  this source i     null                      return i                                  return -1             public void Insert int index  T item                throw new NotSupportedException               public void RemoveAt int index                throw new NotSupportedException               public T this int index                get                       if  index  gt   0  amp  amp  index  lt  this count                  return this source index   this startIndex               else                 throw new IndexOutOfRangeException  quot index quot                      set                       if  index  gt   0  amp  amp  index  lt  this count                  this source index   this startIndex    value              else                 throw new IndexOutOfRangeException  quot index quot                          endregion       region ICollection lt T gt  Members      public void Add T item                throw new NotSupportedException               public void Clear                 throw new NotSupportedException               public bool Contains T item                return this IndexOf item   gt   0             public void CopyTo T   array  int arrayIndex                for  int i 0  i lt this count  i                          array arrayIndex   i    this source i   this startIndex                        public int Count               get   return this count               public bool IsReadOnly               get   return true               public bool Remove T item                throw new NotSupportedException                endregion       region IEnumerable lt T gt  Members      public IEnumerator lt T gt  GetEnumerator                 for  int i   this startIndex  i  lt  this endIndex  i                          yield return this source i                         endregion       region IEnumerable Members      IEnumerator IEnumerable GetEnumerator                 return GetEnumerator                endregion

User · Answer

You could use ArraySegment lt T gt   It s very light-weight as it doesn t copy the array   string   a      one    two    three    four    five     var segment   new ArraySegment lt string gt   a  1  2

User · Answer

You could use a wrapper around the original array  which is IList   like in this  untested  piece of code  public class SubList lt T gt    IList lt T gt         region Fields      private readonly int startIndex      private readonly int endIndex      private readonly int count      private readonly IList lt T gt  source        endregion      public SubList IList lt T gt  source  int startIndex  int count                this source   source          this startIndex   startIndex          this count   count          this endIndex   this startIndex   this count - 1              region IList lt T gt  Members      public int IndexOf T item                if  item    null                        for  int i   this startIndex  i  lt   this endIndex  i                                  if  item Equals this source i                        return i                                  else                       for  int i   this startIndex  i  lt   this endIndex  i                                  if  this source i     null                      return i                                  return -1             public void Insert int index  T item                throw new NotSupportedException               public void RemoveAt int index                throw new NotSupportedException               public T this int index                get                       if  index  gt   0  amp  amp  index  lt  this count                  return this source index   this startIndex               else                 throw new IndexOutOfRangeException  quot index quot                      set                       if  index  gt   0  amp  amp  index  lt  this count                  this source index   this startIndex    value              else                 throw new IndexOutOfRangeException  quot index quot                          endregion       region ICollection lt T gt  Members      public void Add T item                throw new NotSupportedException               public void Clear                 throw new NotSupportedException               public bool Contains T item                return this IndexOf item   gt   0             public void CopyTo T   array  int arrayIndex                for  int i 0  i lt this count  i                          array arrayIndex   i    this source i   this startIndex                        public int Count               get   return this count               public bool IsReadOnly               get   return true               public bool Remove T item                throw new NotSupportedException                endregion       region IEnumerable lt T gt  Members      public IEnumerator lt T gt  GetEnumerator                 for  int i   this startIndex  i  lt  this endIndex  i                          yield return this source i                         endregion       region IEnumerable Members      IEnumerator IEnumerable GetEnumerator                 return GetEnumerator                endregion

User · Answer

Here s a simple extension method that returns a slice as a new array   public static T   Slice lt T gt  this T   arr  uint indexFrom  uint indexTo        if  indexFrom  gt  indexTo            throw new ArgumentOutOfRangeException  indexFrom is bigger than indexTo                uint length   indexTo - indexFrom      T   result   new T length       Array Copy arr  indexFrom  result  0  length        return result      Then you can use it as   byte   slice   foo Slice 0  40

User · Answer

Arrays are enumerable  so your foo already is an IEnumerable lt byte gt  itself  Simply use LINQ sequence methods like Take   to get what you want out of it  don t forget to include the Linq namespace with  using System Linq     byte   foo   new byte 4096    var bar   foo Take 41     If you really need an array from any IEnumerable lt byte gt  value  you could use the ToArray   method for that  That does not seem to be the case here

User · Answer

You could use the arrays CopyTo   method   Or with LINQ you can use Skip   and Take       byte   arr    1  2  3  4  5  6  7  8   var subset   arr Skip 2  Take 2

User · Answer

Another possibility I haven t seen mentioned here  Buffer BlockCopy   is slightly faster than Array Copy    and it has the added benefit of being able to convert on-the-fly from an array of primitives  say  short    to an array of bytes  which can be handy when you ve got numeric arrays that you need to transmit over Sockets

User · Answer

If you want IEnumerable lt byte gt   then just  IEnumerable lt byte gt  data   foo Take x

User · Answer

You could use ArraySegment lt T gt   It s very light-weight as it doesn t copy the array   string   a      one    two    three    four    five     var segment   new ArraySegment lt string gt   a  1  2

User · Answer

using System  using System Collections Generic  using System Linq  using System Text  using System Threading Tasks   namespace data seniens       class Program               static void Main string   args                          new list             float    x new float   11 25f 18 0f 20 0f 10 75f 9 50f  11 25f  18 0f  20 0f  10 75f  9 50f                   variable             float eat sleep area x 1  x 3                 print             foreach  var VARIABLE in x                                if  VARIABLE  lt  x 7                                         Console WriteLine VARIABLE                                                    keep app run         Console ReadLine

User · Answer

You can use Take extension method      var array   new byte    1  2  3  4   var firstTwoItems   array Take 2

User · Answer

For byte arrays System Buffer BlockCopy will give you the very best performance

User · Answer

In C  7 2  you can use Span lt T gt   The benefit of the new System Memory system is that it doesn t need copying around data   The method you need is Slice   Span lt byte gt  slice   foo Slice 0  40     A lot of methods now support Span and IReadOnlySpan  so it will be very straightforward to use this new type   Note that at the time of writing the Span lt T gt  type is not defined in the the most recent version of  NET yet  4 7 1  so to use it you need to install the System Memory package from NuGet

User · Answer

In C  7 2  you can use Span lt T gt   The benefit of the new System Memory system is that it doesn t need copying around data   The method you need is Slice   Span lt byte gt  slice   foo Slice 0  40     A lot of methods now support Span and IReadOnlySpan  so it will be very straightforward to use this new type   Note that at the time of writing the Span lt T gt  type is not defined in the the most recent version of  NET yet  4 7 1  so to use it you need to install the System Memory package from NuGet

User · Answer

If you don t want to add LINQ or other extensions just do   float   subArray   new List lt float gt  myArray  GetRange 0  8  ToArray

User · Answer

Here s a simple extension method that returns a slice as a new array   public static T   Slice lt T gt  this T   arr  uint indexFrom  uint indexTo        if  indexFrom  gt  indexTo            throw new ArgumentOutOfRangeException  indexFrom is bigger than indexTo                uint length   indexTo - indexFrom      T   result   new T length       Array Copy arr  indexFrom  result  0  length        return result      Then you can use it as   byte   slice   foo Slice 0  40

User · Answer

You could use ArraySegment lt T gt   It s very light-weight as it doesn t copy the array   string   a      one    two    three    four    five     var segment   new ArraySegment lt string gt   a  1  2

User · Answer

Starting from C  8 0  Net Core 3 0  Array slicing will be supported  along with the new types Index and Range being added    Range Struct docs Index Struct docs  Index i1   3      number 3 from beginning Index i2    4     number 4 from end int   a     0  1  2  3  4  5  6  7  8  9    Console WriteLine    a i1     a i2          3  6   var slice   a i1  i2        3  4  5     Above code sample taken from the C  8 0 blog    note that the   prefix indicates counting from the end of the array  As shown in the docs example  var words   new string                        index from start    index from end      The           0                    9      quick         1                    8      brown         2                    7      fox           3                    6      jumped        4                    5      over          5                    4      the           6                    3      lazy          7                    2      dog           8                    1                    9  or words Length   0   Range and Index also work outside of slicing arrays  for example with loops  Range range   1  4   foreach  var name in names range     Will loop through the entries 1 through 4    note that at the time of writing this answer  C  8 0 is not yet officially released C  8 x and  Net Core 3 x are now available in Visual Studio 2019 and onwards

User · Answer

For byte arrays System Buffer BlockCopy will give you the very best performance

User · Answer

If you want IEnumerable lt byte gt   then just  IEnumerable lt byte gt  data   foo Take x

User · Answer

I do not think C  supports the Range semantics  You could write an extension method though  like   public static IEnumerator lt Byte gt  Range this byte   array  int start  int end     But like others have said if you do not need to set a start index then Take is all you need

User · Answer

I do not think C  supports the Range semantics  You could write an extension method though  like   public static IEnumerator lt Byte gt  Range this byte   array  int start  int end     But like others have said if you do not need to set a start index then Take is all you need

User · Answer

You can use Take extension method      var array   new byte    1  2  3  4   var firstTwoItems   array Take 2

User · Answer

byte   foo   new byte 4096     byte   bar   foo Take 40  ToArray

User · Answer

Here is an extension function that uses a generic and behaves like the PHP function array slice  Negative offset and length are allowed   public static class Extensions       public static T   Slice lt T gt  this T   arr  int offset  int length                int start  end              Determine start index  handling negative offset          if  offset  lt  0              start   arr Length   offset          else             start   offset              Clamp start index to the bounds of the input array          if  start  lt  0              start   0          else if  start  gt  arr Length              start   arr Length              Determine end index  handling negative length          if  length  lt  0              end   arr Length   length          else             end   start   length              Clamp end index to the bounds of the input array          if  end  lt  0              end   0          if  end  gt  arr Length              end   arr Length              Get the array slice          int len   end - start          T   result   new T len           for  int i   0  i  lt  len  i                          result i    arr start   i                     return result

User · Answer

You could use a wrapper around the original array  which is IList   like in this  untested  piece of code  public class SubList lt T gt    IList lt T gt         region Fields      private readonly int startIndex      private readonly int endIndex      private readonly int count      private readonly IList lt T gt  source        endregion      public SubList IList lt T gt  source  int startIndex  int count                this source   source          this startIndex   startIndex          this count   count          this endIndex   this startIndex   this count - 1              region IList lt T gt  Members      public int IndexOf T item                if  item    null                        for  int i   this startIndex  i  lt   this endIndex  i                                  if  item Equals this source i                        return i                                  else                       for  int i   this startIndex  i  lt   this endIndex  i                                  if  this source i     null                      return i                                  return -1             public void Insert int index  T item                throw new NotSupportedException               public void RemoveAt int index                throw new NotSupportedException               public T this int index                get                       if  index  gt   0  amp  amp  index  lt  this count                  return this source index   this startIndex               else                 throw new IndexOutOfRangeException  quot index quot                      set                       if  index  gt   0  amp  amp  index  lt  this count                  this source index   this startIndex    value              else                 throw new IndexOutOfRangeException  quot index quot                          endregion       region ICollection lt T gt  Members      public void Add T item                throw new NotSupportedException               public void Clear                 throw new NotSupportedException               public bool Contains T item                return this IndexOf item   gt   0             public void CopyTo T   array  int arrayIndex                for  int i 0  i lt this count  i                          array arrayIndex   i    this source i   this startIndex                        public int Count               get   return this count               public bool IsReadOnly               get   return true               public bool Remove T item                throw new NotSupportedException                endregion       region IEnumerable lt T gt  Members      public IEnumerator lt T gt  GetEnumerator                 for  int i   this startIndex  i  lt  this endIndex  i                          yield return this source i                         endregion       region IEnumerable Members      IEnumerator IEnumerable GetEnumerator                 return GetEnumerator                endregion

User · Answer

byte   foo   new byte 4096     byte   bar   foo Take 40  ToArray

User · Answer

You could use a wrapper around the original array  which is IList   like in this  untested  piece of code  public class SubList lt T gt    IList lt T gt         region Fields      private readonly int startIndex      private readonly int endIndex      private readonly int count      private readonly IList lt T gt  source        endregion      public SubList IList lt T gt  source  int startIndex  int count                this source   source          this startIndex   startIndex          this count   count          this endIndex   this startIndex   this count - 1              region IList lt T gt  Members      public int IndexOf T item                if  item    null                        for  int i   this startIndex  i  lt   this endIndex  i                                  if  item Equals this source i                        return i                                  else                       for  int i   this startIndex  i  lt   this endIndex  i                                  if  this source i     null                      return i                                  return -1             public void Insert int index  T item                throw new NotSupportedException               public void RemoveAt int index                throw new NotSupportedException               public T this int index                get                       if  index  gt   0  amp  amp  index  lt  this count                  return this source index   this startIndex               else                 throw new IndexOutOfRangeException  quot index quot                      set                       if  index  gt   0  amp  amp  index  lt  this count                  this source index   this startIndex    value              else                 throw new IndexOutOfRangeException  quot index quot                          endregion       region ICollection lt T gt  Members      public void Add T item                throw new NotSupportedException               public void Clear                 throw new NotSupportedException               public bool Contains T item                return this IndexOf item   gt   0             public void CopyTo T   array  int arrayIndex                for  int i 0  i lt this count  i                          array arrayIndex   i    this source i   this startIndex                        public int Count               get   return this count               public bool IsReadOnly               get   return true               public bool Remove T item                throw new NotSupportedException                endregion       region IEnumerable lt T gt  Members      public IEnumerator lt T gt  GetEnumerator                 for  int i   this startIndex  i  lt  this endIndex  i                          yield return this source i                         endregion       region IEnumerable Members      IEnumerator IEnumerable GetEnumerator                 return GetEnumerator                endregion

User · Answer

Arrays are enumerable  so your foo already is an IEnumerable lt byte gt  itself  Simply use LINQ sequence methods like Take   to get what you want out of it  don t forget to include the Linq namespace with  using System Linq     byte   foo   new byte 4096    var bar   foo Take 41     If you really need an array from any IEnumerable lt byte gt  value  you could use the ToArray   method for that  That does not seem to be the case here

User · Answer

If you want IEnumerable lt byte gt   then just  IEnumerable lt byte gt  data   foo Take x

User · Answer

Another possibility I haven t seen mentioned here  Buffer BlockCopy   is slightly faster than Array Copy    and it has the added benefit of being able to convert on-the-fly from an array of primitives  say  short    to an array of bytes  which can be handy when you ve got numeric arrays that you need to transmit over Sockets

User · Answer

I do not think C  supports the Range semantics  You could write an extension method though  like   public static IEnumerator lt Byte gt  Range this byte   array  int start  int end     But like others have said if you do not need to set a start index then Take is all you need

User · Answer

You can use Take extension method      var array   new byte    1  2  3  4   var firstTwoItems   array Take 2

User · Answer

You could use the arrays CopyTo   method   Or with LINQ you can use Skip   and Take       byte   arr    1  2  3  4  5  6  7  8   var subset   arr Skip 2  Take 2

User · Answer

Starting from C  8 0  Net Core 3 0  Array slicing will be supported  along with the new types Index and Range being added    Range Struct docs Index Struct docs  Index i1   3      number 3 from beginning Index i2    4     number 4 from end int   a     0  1  2  3  4  5  6  7  8  9    Console WriteLine    a i1     a i2          3  6   var slice   a i1  i2        3  4  5     Above code sample taken from the C  8 0 blog    note that the   prefix indicates counting from the end of the array  As shown in the docs example  var words   new string                        index from start    index from end      The           0                    9      quick         1                    8      brown         2                    7      fox           3                    6      jumped        4                    5      over          5                    4      the           6                    3      lazy          7                    2      dog           8                    1                    9  or words Length   0   Range and Index also work outside of slicing arrays  for example with loops  Range range   1  4   foreach  var name in names range     Will loop through the entries 1 through 4    note that at the time of writing this answer  C  8 0 is not yet officially released C  8 x and  Net Core 3 x are now available in Visual Studio 2019 and onwards

User · Answer

Here is an extension function that uses a generic and behaves like the PHP function array slice  Negative offset and length are allowed   public static class Extensions       public static T   Slice lt T gt  this T   arr  int offset  int length                int start  end              Determine start index  handling negative offset          if  offset  lt  0              start   arr Length   offset          else             start   offset              Clamp start index to the bounds of the input array          if  start  lt  0              start   0          else if  start  gt  arr Length              start   arr Length              Determine end index  handling negative length          if  length  lt  0              end   arr Length   length          else             end   start   length              Clamp end index to the bounds of the input array          if  end  lt  0              end   0          if  end  gt  arr Length              end   arr Length              Get the array slice          int len   end - start          T   result   new T len           for  int i   0  i  lt  len  i                          result i    arr start   i                     return result

User · Answer

C  8 now  since 2019  supports Ranges which allows you to achieve Slice much easier  similar to JS syntax   var array   new int     1  2  3  4  5    var slice1   array 2   3         array new Range 2  new Index 3  fromEnd  true    var slice2   array    3          array Range EndAt new Index 3  fromEnd  true    var slice3   array 2             array Range StartAt 2   var slice4   array               array Range All   You can use ranges instead of the well known LINQ functions  Skip    Take    Count

User · Answer

C  8 now  since 2019  supports Ranges which allows you to achieve Slice much easier  similar to JS syntax   var array   new int     1  2  3  4  5    var slice1   array 2   3         array new Range 2  new Index 3  fromEnd  true    var slice2   array    3          array Range EndAt new Index 3  fromEnd  true    var slice3   array 2             array Range StartAt 2   var slice4   array               array Range All   You can use ranges instead of the well known LINQ functions  Skip    Take    Count

User · Answer

static byte   SliceMe byte   source  int length        byte   destfoo   new byte length       Array Copy source  0  destfoo  0  length       return destfoo          var myslice   SliceMe sourcearray 41

User · Answer

This may be a solution that   var result   foo Slice 40  int MaxValue     Then the result is an IEnumerable lt  IEnumerable lt  byte   with a first IEnumerable lt  byte  contains the first 40 bytes of foo  and a second IEnumerable lt  byte  holds the rest   I wrote a wrapper class  the whole iteration is lazy  hope it could help   public static class CollectionSlicer       public static IEnumerable lt IEnumerable lt T gt  gt  Slice lt T gt  this IEnumerable lt T gt  source  params int   steps                if   steps Any step   gt  step    0                         throw new InvalidOperationException  Can t slice a collection with step length 0                       return new Slicer lt T gt  source GetEnumerator    steps  Slice             public sealed class Slicer lt T gt        public Slicer IEnumerator lt T gt  iterator  int   steps                 iterator   iterator           steps   steps           index   0           currentStep   0           isHasNext   true             public int Index               get   return  index               public IEnumerable lt IEnumerable lt T gt  gt  Slice                 var length    steps Length          var index   1          var step   0           for  var i   0   isHasNext    i                        if  i  lt  length                                step    steps i                    currentStep   step - 1                             while   index  lt  index  amp  amp   isHasNext                                 isHasNext   MoveNext                               if   isHasNext                                yield return SliceInternal                    index    step                                     private IEnumerable lt T gt  SliceInternal                 if   currentStep    -1  yield break          yield return  iterator Current           for  var count   0  count  lt   currentStep  amp  amp   isHasNext    count                         isHasNext   MoveNext                 if   isHasNext                                yield return  iterator Current                                     private bool MoveNext                    index          return  iterator MoveNext               private readonly IEnumerator lt T gt   iterator      private readonly int    steps      private volatile bool  isHasNext      private volatile int  currentStep      private volatile int  index

User · Answer

This may be a solution that   var result   foo Slice 40  int MaxValue     Then the result is an IEnumerable lt  IEnumerable lt  byte   with a first IEnumerable lt  byte  contains the first 40 bytes of foo  and a second IEnumerable lt  byte  holds the rest   I wrote a wrapper class  the whole iteration is lazy  hope it could help   public static class CollectionSlicer       public static IEnumerable lt IEnumerable lt T gt  gt  Slice lt T gt  this IEnumerable lt T gt  source  params int   steps                if   steps Any step   gt  step    0                         throw new InvalidOperationException  Can t slice a collection with step length 0                       return new Slicer lt T gt  source GetEnumerator    steps  Slice             public sealed class Slicer lt T gt        public Slicer IEnumerator lt T gt  iterator  int   steps                 iterator   iterator           steps   steps           index   0           currentStep   0           isHasNext   true             public int Index               get   return  index               public IEnumerable lt IEnumerable lt T gt  gt  Slice                 var length    steps Length          var index   1          var step   0           for  var i   0   isHasNext    i                        if  i  lt  length                                step    steps i                    currentStep   step - 1                             while   index  lt  index  amp  amp   isHasNext                                 isHasNext   MoveNext                               if   isHasNext                                yield return SliceInternal                    index    step                                     private IEnumerable lt T gt  SliceInternal                 if   currentStep    -1  yield break          yield return  iterator Current           for  var count   0  count  lt   currentStep  amp  amp   isHasNext    count                         isHasNext   MoveNext                 if   isHasNext                                yield return  iterator Current                                     private bool MoveNext                    index          return  iterator MoveNext               private readonly IEnumerator lt T gt   iterator      private readonly int    steps      private volatile bool  isHasNext      private volatile int  currentStep      private volatile int  index

User · Answer

Arrays are enumerable  so your foo already is an IEnumerable lt byte gt  itself  Simply use LINQ sequence methods like Take   to get what you want out of it  don t forget to include the Linq namespace with  using System Linq     byte   foo   new byte 4096    var bar   foo Take 41     If you really need an array from any IEnumerable lt byte gt  value  you could use the ToArray   method for that  That does not seem to be the case here

User · Answer

I do not think C  supports the Range semantics  You could write an extension method though  like   public static IEnumerator lt Byte gt  Range this byte   array  int start  int end     But like others have said if you do not need to set a start index then Take is all you need

User · Answer

using System  using System Collections Generic  using System Linq  using System Text  using System Threading Tasks   namespace data seniens       class Program               static void Main string   args                          new list             float    x new float   11 25f 18 0f 20 0f 10 75f 9 50f  11 25f  18 0f  20 0f  10 75f  9 50f                   variable             float eat sleep area x 1  x 3                 print             foreach  var VARIABLE in x                                if  VARIABLE  lt  x 7                                         Console WriteLine VARIABLE                                                    keep app run         Console ReadLine

User · Answer

static byte   SliceMe byte   source  int length        byte   destfoo   new byte length       Array Copy source  0  destfoo  0  length       return destfoo          var myslice   SliceMe sourcearray 41

User · Answer

You can use Take extension method      var array   new byte    1  2  3  4   var firstTwoItems   array Take 2

User · Answer

You could use the arrays CopyTo   method   Or with LINQ you can use Skip   and Take       byte   arr    1  2  3  4  5  6  7  8   var subset   arr Skip 2  Take 2

User · Answer

If you want IEnumerable lt byte gt   then just  IEnumerable lt byte gt  data   foo Take x

[c#] Array slices in C#

Examples related to c#

Examples related to arrays