covert between byte[] and int []

[Ray Z]

So far, I get the idea that if I want to use both the unmanaged and managed
memory, I can not avoid memory copy. But I DO need to avoid it. I get a idea
that maybe I could use "union" to convert byte[] to int[] and so on. Here is
my source code, I wonder if this will work with GC?

[StructLayout(La youtKind.Explic it)]

struct MyUnion

{

[FieldOffset(0)]

public int[] a;

[FieldOffset(0)]

public byte[] b;

}

After I define this "union". I can use the following code to alloc and
access the data buffer:
MyUnion mu = new MyUnion();
mu.a = new int[640*480];
//if I like access it as byte[]
byte[] bp = mu.b;

will this work?

[Nicholas Paldino [.NET/C# MVP]]

Ray,

You have two options here. The first is to use unsafe code, and then
cast the pointer to the byte array (which is really a pointer to a location
in memory to a byte) to a pointer to an integer, and then work from there.

If you want a purely managed solution, then I would use the static
BlockCopy method on the Buffer class to copy the bytes from the byte array
to an appropriately-sized integer array.

Hope this helps.
--
- Nicholas Paldino [.NET/C# MVP]
- mv*@spam.guard. caspershouse.co m

"Ray Z" <su*********@ho tmail.com> wrote in message
news:uo******** ******@TK2MSFTN GP12.phx.gbl...

So far, I get the idea that if I want to use both the unmanaged and managed memory, I can not avoid memory copy. But I DO need to avoid it. I get a idea that maybe I could use "union" to convert byte[] to int[] and so on. Here is my source code, I wonder if this will work with GC?

[StructLayout(La youtKind.Explic it)]

struct MyUnion

{

[FieldOffset(0)]

public int[] a;

[FieldOffset(0)]

public byte[] b;

}

After I define this "union". I can use the following code to alloc and
access the data buffer:
MyUnion mu = new MyUnion();
mu.a = new int[640*480];
//if I like access it as byte[]
byte[] bp = mu.b;

will this work?

[Ray Z]

Thanks.
Then, what's wrong with my approach?
In my case, I can not use copy for sure because I am talking about buffer
size at least 2M bytes.
About the unsafe code, how can I cast a byte* to a byte[]? I need byte[]
because the stream reader (I need read image data from file some times) need
byte[] as it's parameter.

Again, go back my approach, is there something wrong?
"Nicholas Paldino [.NET/C# MVP]" <mv*@spam.guard .caspershouse.c om> wrote in
message news:us******** *****@TK2MSFTNG P11.phx.gbl...

Ray,

You have two options here. The first is to use unsafe code, and then
cast the pointer to the byte array (which is really a pointer to a location in memory to a byte) to a pointer to an integer, and then work from there.

If you want a purely managed solution, then I would use the static
BlockCopy method on the Buffer class to copy the bytes from the byte array
to an appropriately-sized integer array.

Hope this helps.
--
- Nicholas Paldino [.NET/C# MVP]
- mv*@spam.guard. caspershouse.co m

"Ray Z" <su*********@ho tmail.com> wrote in message
news:uo******** ******@TK2MSFTN GP12.phx.gbl...

So far, I get the idea that if I want to use both the unmanaged and managed

memory, I can not avoid memory copy. But I DO need to avoid it. I get a

idea

that maybe I could use "union" to convert byte[] to int[] and so on.

Here is

my source code, I wonder if this will work with GC?

[StructLayout(La youtKind.Explic it)]

struct MyUnion

{

[FieldOffset(0)]

public int[] a;

[FieldOffset(0)]

public byte[] b;

}

After I define this "union". I can use the following code to alloc and
access the data buffer:
MyUnion mu = new MyUnion();
mu.a = new int[640*480];
//if I like access it as byte[]
byte[] bp = mu.b;

will this work?

[Nicholas Paldino [.NET/C# MVP]]

Ray,

Your approach would work fine. The only reason I don't like it is
because it associates a copy of the array in question with the field. From
a design point of view, I would rather have two separate variables which
indicate that one is a different representation of the same thing.

Also, I don't like having to define a new type explicitly for this
purpose, when there are methods to do so.
--
- Nicholas Paldino [.NET/C# MVP]
- mv*@spam.guard. caspershouse.co m

"Ray Z" <su*********@ho tmail.com> wrote in message
news:%2******** ********@tk2msf tngp13.phx.gbl. ..

Thanks.
Then, what's wrong with my approach?
In my case, I can not use copy for sure because I am talking about buffer
size at least 2M bytes.
About the unsafe code, how can I cast a byte* to a byte[]? I need byte[]
because the stream reader (I need read image data from file some times) need byte[] as it's parameter.

Again, go back my approach, is there something wrong?
"Nicholas Paldino [.NET/C# MVP]" <mv*@spam.guard .caspershouse.c om> wrote in message news:us******** *****@TK2MSFTNG P11.phx.gbl...

Ray,

You have two options here. The first is to use unsafe code, and then cast the pointer to the byte array (which is really a pointer to a

location

in memory to a byte) to a pointer to an integer, and then work from there.
If you want a purely managed solution, then I would use the static
BlockCopy method on the Buffer class to copy the bytes from the byte array to an appropriately-sized integer array.

Hope this helps.
--
- Nicholas Paldino [.NET/C# MVP]
- mv*@spam.guard. caspershouse.co m

"Ray Z" <su*********@ho tmail.com> wrote in message
news:uo******** ******@TK2MSFTN GP12.phx.gbl...

So far, I get the idea that if I want to use both the unmanaged and

managed

memory, I can not avoid memory copy. But I DO need to avoid it. I get

a idea

that maybe I could use "union" to convert byte[] to int[] and so on.

Here

is

my source code, I wonder if this will work with GC?

[StructLayout(La youtKind.Explic it)]

struct MyUnion

{

[FieldOffset(0)]

public int[] a;

[FieldOffset(0)]

public byte[] b;

}

After I define this "union". I can use the following code to alloc and
access the data buffer:
MyUnion mu = new MyUnion();
mu.a = new int[640*480];
//if I like access it as byte[]
byte[] bp = mu.b;

will this work?

[Ray Z]

I do not like "bad code" although it works. So I want to make some thing
clear. In your second approach, you will use a BlockCopy. After I call this
function, the system will COPY all the data from one place to another place
(so, we will get two copy of the data after it) or just give the reference
to another array (so we have only one copy of data but have two refernce of
it.)? I need make this clear because I can not afford the copy in my
application. I am working on a buffer size more the 2M, the COPY again and
again will terribly reduce performance. And, in your first approach, I did
not get the way to cast a pointer (byte*) back to byte[].

"Nicholas Paldino [.NET/C# MVP]" <mv*@spam.guard .caspershouse.c om> wrote in
message news:uP******** ******@TK2MSFTN GP10.phx.gbl...

Ray,

Your approach would work fine. The only reason I don't like it is
because it associates a copy of the array in question with the field. From a design point of view, I would rather have two separate variables which
indicate that one is a different representation of the same thing.

Also, I don't like having to define a new type explicitly for this
purpose, when there are methods to do so.
--
- Nicholas Paldino [.NET/C# MVP]
- mv*@spam.guard. caspershouse.co m

"Ray Z" <su*********@ho tmail.com> wrote in message
news:%2******** ********@tk2msf tngp13.phx.gbl. ..

Thanks.
Then, what's wrong with my approach?
In my case, I can not use copy for sure because I am talking about buffer

size at least 2M bytes.
About the unsafe code, how can I cast a byte* to a byte[]? I need byte[]
because the stream reader (I need read image data from file some times) need

byte[] as it's parameter.

Again, go back my approach, is there something wrong?
"Nicholas Paldino [.NET/C# MVP]" <mv*@spam.guard .caspershouse.c om> wrote

in

message news:us******** *****@TK2MSFTNG P11.phx.gbl...

Ray,

You have two options here. The first is to use unsafe code, and

then cast the pointer to the byte array (which is really a pointer to a

location

in memory to a byte) to a pointer to an integer, and then work from there.
If you want a purely managed solution, then I would use the static
BlockCopy method on the Buffer class to copy the bytes from the byte array to an appropriately-sized integer array.

Hope this helps.
--
- Nicholas Paldino [.NET/C# MVP]
- mv*@spam.guard. caspershouse.co m

"Ray Z" <su*********@ho tmail.com> wrote in message
news:uo******** ******@TK2MSFTN GP12.phx.gbl...
> So far, I get the idea that if I want to use both the unmanaged and
managed
> memory, I can not avoid memory copy. But I DO need to avoid it. I get a

idea
> that maybe I could use "union" to convert byte[] to int[] and so on.

Here

is
> my source code, I wonder if this will work with GC?
>
> [StructLayout(La youtKind.Explic it)]
>
> struct MyUnion
>
> {
>
> [FieldOffset(0)]
>
> public int[] a;
>
> [FieldOffset(0)]
>
> public byte[] b;
>
> }
>
> After I define this "union". I can use the following code to alloc

and > access the data buffer:
> MyUnion mu = new MyUnion();
> mu.a = new int[640*480];
> //if I like access it as byte[]
> byte[] bp = mu.b;
>
> will this work?
>
>

[Ted Miller]

Intriguing, but flawed. If you create an array of length x, then you will
only be able to access the first x elements of the array, regardless of how
you coax the Array reference.

[StructLayout(La youtKind.Explic it)]
struct MyUnion {
[FieldOffset(0)] public int[] i;
[FieldOffset(0)] public byte[] b;
}

MyUnion mu = new MyUnion();
mu.i = new int[1] { 0x11223344 };

byte[] bp = mu.b;

bp[0] = 0x00 // does what you expect, more or less
bp[1] = 0xaa; // array bounds exception

However this did let us get around the type system -- and opens up a
dangerous hole that perhaps Microsoft should be aware of. This code:

[StructLayout(La youtKind.Explic it)]
struct MyUnion {
[FieldOffset(0)]
public long[] l;
[FieldOffset(0)]
public byte[] b;
}

MyUnion mu = new MyUnion();
mu.b = new byte[1] { 0xaa };

long[] lp = mu.l;

lp[0] = 0x1122334455667 788;

compiles and runs -- and, I assume, writes 7 bytes beyond the end of the
where it should be allowed to write.

"Nicholas Paldino [.NET/C# MVP]" <mv*@spam.guard .caspershouse.c om> wrote in
message news:uP******** ******@TK2MSFTN GP10.phx.gbl...

Ray,

Your approach would work fine. The only reason I don't like it is
because it associates a copy of the array in question with the field. From a design point of view, I would rather have two separate variables which
indicate that one is a different representation of the same thing.

Also, I don't like having to define a new type explicitly for this
purpose, when there are methods to do so.
--
- Nicholas Paldino [.NET/C# MVP]
- mv*@spam.guard. caspershouse.co m

"Ray Z" <su*********@ho tmail.com> wrote in message
news:%2******** ********@tk2msf tngp13.phx.gbl. ..

Thanks.
Then, what's wrong with my approach?
In my case, I can not use copy for sure because I am talking about buffer

size at least 2M bytes.
About the unsafe code, how can I cast a byte* to a byte[]? I need byte[]
because the stream reader (I need read image data from file some times) need

byte[] as it's parameter.

Again, go back my approach, is there something wrong?
"Nicholas Paldino [.NET/C# MVP]" <mv*@spam.guard .caspershouse.c om> wrote

in

message news:us******** *****@TK2MSFTNG P11.phx.gbl...

Ray,

You have two options here. The first is to use unsafe code, and

then cast the pointer to the byte array (which is really a pointer to a

location

in memory to a byte) to a pointer to an integer, and then work from there.
If you want a purely managed solution, then I would use the static
BlockCopy method on the Buffer class to copy the bytes from the byte array to an appropriately-sized integer array.

Hope this helps.
--
- Nicholas Paldino [.NET/C# MVP]
- mv*@spam.guard. caspershouse.co m

"Ray Z" <su*********@ho tmail.com> wrote in message
news:uo******** ******@TK2MSFTN GP12.phx.gbl...
> So far, I get the idea that if I want to use both the unmanaged and
managed
> memory, I can not avoid memory copy. But I DO need to avoid it. I get a

idea
> that maybe I could use "union" to convert byte[] to int[] and so on.

Here

is
> my source code, I wonder if this will work with GC?
>
> [StructLayout(La youtKind.Explic it)]
>
> struct MyUnion
>
> {
>
> [FieldOffset(0)]
>
> public int[] a;
>
> [FieldOffset(0)]
>
> public byte[] b;
>
> }
>
> After I define this "union". I can use the following code to alloc

and > access the data buffer:
> MyUnion mu = new MyUnion();
> mu.a = new int[640*480];
> //if I like access it as byte[]
> byte[] bp = mu.b;
>
> will this work?
>
>

[Austin Ehlers]

On Mon, 3 Nov 2003 15:17:51 -0500, "Ray Z" <su*********@ho tmail.com>
wrote:

So far, I get the idea that if I want to use both the unmanaged and managed
memory, I can not avoid memory copy. But I DO need to avoid it.

<snip>

Well, I got a little bored. Take a look at:

http://home.comcast.net/~aehlers/MemMan.cs

The only copying that occurs is when converting to/from arrays. You
can manipulate the memory with pointers without any copying going on.

Austin Ehlers

[William Stacey]

> not get the way to cast a pointer (byte*) back to byte[].

You can't cast pointers back to managed types.
Keep it as a byte[] if you need to pass it to a stream. This way you can
also work with it as an int* if you need.

--
William Stacey, MVP

[Jeffrey Tan[MSFT]]

Hi Ray,

Thanks for posting in this group.
I have reviewed your post. Just as Ted points out, your approach of using
union is almost a good workaround, but it has some problem.
You can find the detailed problems in Ted's post.(It is mainly due to .Net
maintains the readonly length property of array).

While the unmanaged approach many people suggested also has one problem, we
can not find a way to convert umanaged byte pointer to managed byte[].

At this time, I think the only way of doing this is copying memory which
you do not like.

I will do some research for this issue, I will reply to you as soon as I
research out.
Thanks for your understanding.

Best regards,
Jeffrey Tan
Microsoft Online Partner Support
Get Secure! - www.microsoft.com/security
This posting is provided "as is" with no warranties and confers no rights.

--------------------
| From: "Ray Z" <su*********@ho tmail.com>
| References: <uo************ **@TK2MSFTNGP12 .phx.gbl>
<us************ *@TK2MSFTNGP11. phx.gbl>
<#F************ **@tk2msftngp13 .phx.gbl>
<uP************ **@TK2MSFTNGP10 .phx.gbl>
| Subject: Re: covert between byte[] and int []
| Date: Mon, 3 Nov 2003 16:57:53 -0500
| Lines: 115
| X-Priority: 3
| X-MSMail-Priority: Normal
| X-Newsreader: Microsoft Outlook Express 6.00.3790.0
| X-MimeOLE: Produced By Microsoft MimeOLE V6.00.3790.0
| Message-ID: <#P************ **@TK2MSFTNGP11 .phx.gbl>
| Newsgroups: microsoft.publi c.dotnet.langua ges.csharp
| NNTP-Posting-Host: x42071bc2.ip.e-nt.net 66.7.27.194
| Path: cpmsftngxa06.ph x.gbl!TK2MSFTNG P08.phx.gbl!TK2 MSFTNGP11.phx.g bl
| Xref: cpmsftngxa06.ph x.gbl microsoft.publi c.dotnet.langua ges.csharp:1964 16
| X-Tomcat-NG: microsoft.publi c.dotnet.langua ges.csharp
|
| I do not like "bad code" although it works. So I want to make some thing
| clear. In your second approach, you will use a BlockCopy. After I call
this
| function, the system will COPY all the data from one place to another
place
| (so, we will get two copy of the data after it) or just give the reference
| to another array (so we have only one copy of data but have two refernce
of
| it.)? I need make this clear because I can not afford the copy in my
| application. I am working on a buffer size more the 2M, the COPY again and
| again will terribly reduce performance. And, in your first approach, I did
| not get the way to cast a pointer (byte*) back to byte[].
|
| "Nicholas Paldino [.NET/C# MVP]" <mv*@spam.guard .caspershouse.c om> wrote
in
| message news:uP******** ******@TK2MSFTN GP10.phx.gbl...
| > Ray,
| >
| > Your approach would work fine. The only reason I don't like it is
| > because it associates a copy of the array in question with the field.
| From
| > a design point of view, I would rather have two separate variables which
| > indicate that one is a different representation of the same thing.
| >
| > Also, I don't like having to define a new type explicitly for this
| > purpose, when there are methods to do so.
| >
| >
| > --
| > - Nicholas Paldino [.NET/C# MVP]
| > - mv*@spam.guard. caspershouse.co m
| >
| > "Ray Z" <su*********@ho tmail.com> wrote in message
| > news:%2******** ********@tk2msf tngp13.phx.gbl. ..
| > > Thanks.
| > > Then, what's wrong with my approach?
| > > In my case, I can not use copy for sure because I am talking about
| buffer
| > > size at least 2M bytes.
| > > About the unsafe code, how can I cast a byte* to a byte[]? I need
byte[]
| > > because the stream reader (I need read image data from file some
times)
| > need
| > > byte[] as it's parameter.
| > >
| > > Again, go back my approach, is there something wrong?
| > >
| > >
| > > "Nicholas Paldino [.NET/C# MVP]" <mv*@spam.guard .caspershouse.c om>
wrote
| > in
| > > message news:us******** *****@TK2MSFTNG P11.phx.gbl...
| > > > Ray,
| > > >
| > > > You have two options here. The first is to use unsafe code, and
| > then
| > > > cast the pointer to the byte array (which is really a pointer to a
| > > location
| > > > in memory to a byte) to a pointer to an integer, and then work from
| > there.
| > > >
| > > > If you want a purely managed solution, then I would use the
static
| > > > BlockCopy method on the Buffer class to copy the bytes from the byte
| > array
| > > > to an appropriately-sized integer array.
| > > >
| > > > Hope this helps.
| > > >
| > > >
| > > > --
| > > > - Nicholas Paldino [.NET/C# MVP]
| > > > - mv*@spam.guard. caspershouse.co m
| > > >
| > > > "Ray Z" <su*********@ho tmail.com> wrote in message
| > > > news:uo******** ******@TK2MSFTN GP12.phx.gbl...
| > > > > So far, I get the idea that if I want to use both the unmanaged
and
| > > > managed
| > > > > memory, I can not avoid memory copy. But I DO need to avoid it. I
| get
| > a
| > > > idea
| > > > > that maybe I could use "union" to convert byte[] to int[] and so
on.
| > > Here
| > > > is
| > > > > my source code, I wonder if this will work with GC?
| > > > >
| > > > > [StructLayout(La youtKind.Explic it)]
| > > > >
| > > > > struct MyUnion
| > > > >
| > > > > {
| > > > >
| > > > > [FieldOffset(0)]
| > > > >
| > > > > public int[] a;
| > > > >
| > > > > [FieldOffset(0)]
| > > > >
| > > > > public byte[] b;
| > > > >
| > > > > }
| > > > >
| > > > > After I define this "union". I can use the following code to alloc
| and
| > > > > access the data buffer:
| > > > > MyUnion mu = new MyUnion();
| > > > > mu.a = new int[640*480];
| > > > > //if I like access it as byte[]
| > > > > byte[] bp = mu.b;
| > > > >
| > > > > will this work?
| > > > >
| > > > >
| > > >
| > > >
| > >
| > >
| >
| >
|
|
|

[Richard A. Lowe]

Hi Jeffrey, in regards to this, could you look at my post "Using
StructLayout causes app to end - no CLR exception" because it addresses (and
arguably 'fixes') the issue with fixed-length. In short - in isolation I
made the union suggestion work by using another unioned class to manipulate
the length. However, the result (when repeated in a for loop) is not at all
stable. Please have a look.

Richard

--
Veuillez m'excuser, mon Français est très pauvre. Cependant, si vous voyez
mauvais C #, c'est mon défaut!
""Jeffrey Tan[MSFT]"" <v-*****@online.mi crosoft.com> wrote in message
news:dx******** *****@cpmsftngx a06.phx.gbl...

Hi Ray,

Thanks for posting in this group.
I have reviewed your post. Just as Ted points out, your approach of using
union is almost a good workaround, but it has some problem.
You can find the detailed problems in Ted's post.(It is mainly due to .Net
maintains the readonly length property of array).

While the unmanaged approach many people suggested also has one problem, we can not find a way to convert umanaged byte pointer to managed byte[].

At this time, I think the only way of doing this is copying memory which
you do not like.

I will do some research for this issue, I will reply to you as soon as I
research out.
Thanks for your understanding.

Best regards,
Jeffrey Tan
Microsoft Online Partner Support
Get Secure! - www.microsoft.com/security
This posting is provided "as is" with no warranties and confers no rights.

--------------------
| From: "Ray Z" <su*********@ho tmail.com>
| References: <uo************ **@TK2MSFTNGP12 .phx.gbl>
<us************ *@TK2MSFTNGP11. phx.gbl>
<#F************ **@tk2msftngp13 .phx.gbl>
<uP************ **@TK2MSFTNGP10 .phx.gbl>
| Subject: Re: covert between byte[] and int []
| Date: Mon, 3 Nov 2003 16:57:53 -0500
| Lines: 115
| X-Priority: 3
| X-MSMail-Priority: Normal
| X-Newsreader: Microsoft Outlook Express 6.00.3790.0
| X-MimeOLE: Produced By Microsoft MimeOLE V6.00.3790.0
| Message-ID: <#P************ **@TK2MSFTNGP11 .phx.gbl>
| Newsgroups: microsoft.publi c.dotnet.langua ges.csharp
| NNTP-Posting-Host: x42071bc2.ip.e-nt.net 66.7.27.194
| Path: cpmsftngxa06.ph x.gbl!TK2MSFTNG P08.phx.gbl!TK2 MSFTNGP11.phx.g bl
| Xref: cpmsftngxa06.ph x.gbl microsoft.publi c.dotnet.langua ges.csharp:1964 16 | X-Tomcat-NG: microsoft.publi c.dotnet.langua ges.csharp
|
| I do not like "bad code" although it works. So I want to make some thing
| clear. In your second approach, you will use a BlockCopy. After I call
this
| function, the system will COPY all the data from one place to another
place
| (so, we will get two copy of the data after it) or just give the reference | to another array (so we have only one copy of data but have two refernce
of
| it.)? I need make this clear because I can not afford the copy in my
| application. I am working on a buffer size more the 2M, the COPY again and | again will terribly reduce performance. And, in your first approach, I did | not get the way to cast a pointer (byte*) back to byte[].
|
| "Nicholas Paldino [.NET/C# MVP]" <mv*@spam.guard .caspershouse.c om> wrote
in
| message news:uP******** ******@TK2MSFTN GP10.phx.gbl...
| > Ray,
| >
| > Your approach would work fine. The only reason I don't like it is
| > because it associates a copy of the array in question with the field.
| From
| > a design point of view, I would rather have two separate variables which | > indicate that one is a different representation of the same thing.
| >
| > Also, I don't like having to define a new type explicitly for this
| > purpose, when there are methods to do so.
| >
| >
| > --
| > - Nicholas Paldino [.NET/C# MVP]
| > - mv*@spam.guard. caspershouse.co m
| >
| > "Ray Z" <su*********@ho tmail.com> wrote in message
| > news:%2******** ********@tk2msf tngp13.phx.gbl. ..
| > > Thanks.
| > > Then, what's wrong with my approach?
| > > In my case, I can not use copy for sure because I am talking about
| buffer
| > > size at least 2M bytes.
| > > About the unsafe code, how can I cast a byte* to a byte[]? I need
byte[]
| > > because the stream reader (I need read image data from file some
times)
| > need
| > > byte[] as it's parameter.
| > >
| > > Again, go back my approach, is there something wrong?
| > >
| > >
| > > "Nicholas Paldino [.NET/C# MVP]" <mv*@spam.guard .caspershouse.c om>
wrote
| > in
| > > message news:us******** *****@TK2MSFTNG P11.phx.gbl...
| > > > Ray,
| > > >
| > > > You have two options here. The first is to use unsafe code, and | > then
| > > > cast the pointer to the byte array (which is really a pointer to a
| > > location
| > > > in memory to a byte) to a pointer to an integer, and then work from | > there.
| > > >
| > > > If you want a purely managed solution, then I would use the
static
| > > > BlockCopy method on the Buffer class to copy the bytes from the byte | > array
| > > > to an appropriately-sized integer array.
| > > >
| > > > Hope this helps.
| > > >
| > > >
| > > > --
| > > > - Nicholas Paldino [.NET/C# MVP]
| > > > - mv*@spam.guard. caspershouse.co m
| > > >
| > > > "Ray Z" <su*********@ho tmail.com> wrote in message
| > > > news:uo******** ******@TK2MSFTN GP12.phx.gbl...
| > > > > So far, I get the idea that if I want to use both the unmanaged
and
| > > > managed
| > > > > memory, I can not avoid memory copy. But I DO need to avoid it. I | get
| > a
| > > > idea
| > > > > that maybe I could use "union" to convert byte[] to int[] and so
on.
| > > Here
| > > > is
| > > > > my source code, I wonder if this will work with GC?
| > > > >
| > > > > [StructLayout(La youtKind.Explic it)]
| > > > >
| > > > > struct MyUnion
| > > > >
| > > > > {
| > > > >
| > > > > [FieldOffset(0)]
| > > > >
| > > > > public int[] a;
| > > > >
| > > > > [FieldOffset(0)]
| > > > >
| > > > > public byte[] b;
| > > > >
| > > > > }
| > > > >
| > > > > After I define this "union". I can use the following code to alloc | and
| > > > > access the data buffer:
| > > > > MyUnion mu = new MyUnion();
| > > > > mu.a = new int[640*480];
| > > > > //if I like access it as byte[]
| > > > > byte[] bp = mu.b;
| > > > >
| > > > > will this work?
| > > > >
| > > > >
| > > >
| > > >
| > >
| > >
| >
| >
|
|
|