0

Is it possible to control the index position in a byte[] array? In the following code I expect the return value of value1 enters in the first seven bytes in join and the return value of value2 enters in the 8 9 10 11 position sequentially. But this is not happening. The first seven bytes are lost because the index is in 0 position always. How to control the index position?

static void Main(string[] args)
    {
        byte[] join = new byte[15];
        join = value1(); //seven byte enters. 
        join = value2(); //next four byte enters.
                               // 'join' should now have eleven bytes. 
        string a = Encoding.UTF8.GetString(join);
        Console.WriteLine(a);
        Console.ReadLine();
    }

    public static byte[] value1() 
    {

        string first = "welcome";
        byte[] f = Encoding.UTF8.GetBytes(first);
        return f;// seven byte returning.

    }

    public static byte[] value2() 
    {
        string second = "home";
        byte[] s = Encoding.UTF8.GetBytes(second);
        return s;//four byte returning.
    }

I know the code can be reorganize using Array.Copy() or Buffer.BlockCopy(). But these two methods are time consuming if the code runs 100,000 times or more. I'm looking forward to avoid these two methods and get the return values directly inside join.

---Thanks

Improve this question

3 Answers 3

Reset to default
4

There is a way to do what you want, but you have to be careful. This GetBytes overload lets you specify the byte array into which the bytes will be copied, and the index at which they will be copied. So, in your example, it would look like this:

    byte[] join = new byte[15];
    int ix = 0;
    ix = ix + Encoding.UTF8.GetBytes(first, 0, first.Length, join, ix);
    ix = ix + Encoding.UTF8.GetBytes(second, 0, second.Length, join, ix);
    string a = Encoding.UTF8.GetString(join, 0, ix);

The ix variable here keeps track of the total number of bytes that are encoded.

You have to be careful here to allocate enough bytes in your join array, and you have to keep track of the number of bytes encoded because with UTF-8 (and many other encodings) a single character could require multiple bytes.

You'll also want to see the GetString overload that lets you specify the starting position in the array and the number of bytes.

If you want to write methods that do this like your value1 and value2 methods, you'll have to pass the byte array and the array index to the methods. And those methods will have to return the number of bytes they encoded, or they'll have to add that value to the index and return the new index.

Improve this answer
Sign up to request clarification or add additional context in comments.

3 Comments

Your code looks interesting but right now the main issue is time. I was wrong at first and thought Array.Copy() was slowing down my code. But then I saw it is the second fastest method and thanks to digEmAll I saved a few seconds by using Buffer.BlockCopy(). From digEmAll's answer, if your code runs faster than Buffer.BlockCopy() I might accept it. :)
@Giliweed: On the face of it, my code should be faster because it writes the bytes directly to the destination array rather than writing to an intermediate array and then copying to the destination. It's up to you to do the benchmark, if it's that important. But if this isn't the bottleneck, then you're wasting your time optimizing it.
+1 : This should be definitely faster than other methods, since it saves some arrays allocation. As you said, the only drawback is you need to preallocate an initial array making an assumption on the maximum byte array length...
3

value1 and value2 methods returns a byte array, while you presumably want to append the values to the existing join array.

You can use Array.Copy (or Buffer.BlockCopy) to put the returned values inside join array :

var v1 = value1(); //seven byte returned. 
var v2 = value2(); //next four byte returned.
var join = new byte[v1.Length + v2.Length];

// copy v1 at index 0 of join
Array.Copy(v1, 0, join, 0, v1.Length); 
// copy v2 at index v1.Length of join
Array.Copy(v2, 0, join, v1.Length, v2.Length);

EDIT :

I did a small benchmark to test the performances of the proposed methods, and here's the result (with 6 millions of repetions for each method) :

Benchmark results (6000000 repetitions) :
JoinCodeUsingArrayCopy       : 4076021 ticks (1304 ms)
JoinCodeUsingSetItems        : 4873634 ticks (1559 ms)
JoinCodeUsingList            : 8729925 ticks (2793 ms)
JoinCodeUsingBufferBlockCopy : 3665075 ticks (1172 ms)

Benchmark code here.

As you can see Array.Copy/Buffer.BlockCopy are the fastest methods, even if the method using list is not much much slower (we're talking about 1.5 second of difference on 6 million iterations after all).
Probably I would go for the list method because is the cleanest since it does not require to work directly with offsets/start indexes.

Improve this answer

12 Comments

I said I want to avoid Array.Copy() because it slows down my code.
Array.Copy is usually the fastest way to fill an array (even faster than looping on values)... it seems really really strange to me that it's slowing down your code... I would really be interested in seeing this code...
when the code runs 100,000 or more times then I'll have 200,000 or more Array.Copy()s running in my code. Can you imagine how much time it takes to do that? That's way I wish to get the value directly instead of using two Array.Copy() methods.
If you don't use Array.Copy you will use another way to put your returned values into the join array, for example the SetItems method shown in the other answer, and you will call it 200,000 times as well. Do you think the code in the other answer performs less operations than Array.Copy ? It does exactly the same number of operations but probably Array.Copy is slighlty more optimized.
give me some time to test and see which one is more faster in my actual code. :)
|
3

Instead of assigning items of your array, you are throwing away the new byte[15] and assigning it to new array. You can try using List<byte> first then convert it to an array:

var byteList = new List<byte>(15);

byteList.AddRange(value1());
byteList.AddRange(value2());

byte[] join = byteList.ToArray();

Another alternative is to create an extension method for your array, something like this:

public static void SetItems<T>(this T[] source, int startIndex, IEnumerable<T> items)
{
     // I omitted the checks (index, length, null etc.) but you should add them
     int i = startIndex;

     foreach(var item in items)
          source[i++] = item;
}

Then call it:

byte[] join = new byte[15];
join.SetItems(0, value1());
join.SetItems(4, value2());

This should be faster than first option because it doesn't create a list but it requires you to know the startIndex, in this case it shouldn't be a problem..

Improve this answer

10 Comments

And another approach: IEnumerable<byte> byteEnumerable = value1(); byteEnumerable = byteEnumerable.Concat(value2());
Is it faster then 'Array.Copy()' or 'Buffer.BlockCopy()' if the code runs 100,000? The code which is more time efficient matters.
@Giliweed - for most people, correct is the first thing you should optimize for, before speed.
why did you give '<T>' after SetItems is it something special? what does 'T[]' represents?
@Giliweed I make it generic.So it will work for all one-dimensional arrays, e.g. int[], short[], string[]
|

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service and acknowledge you have read our privacy policy.

Start asking to get answers

Find the answer to your question by asking.

Ask question

Explore related questions

See similar questions with these tags.