How to get the memory address of a file

Question

In a WCE app I’m looking for a way to copy a file (I only have to file name/path of it) to a specific memory address. The file is rather large’ish, ~40MB, so with limited resources, I was hoping to avoid reading the whole file into memory (byte array), by using the answer from this post: Copy data from from IntPtr to IntPtr

[DllImport("kernel32.dll", EntryPoint = "CopyMemory", SetLastError = false)] 
public static extern void CopyMemory(IntPtr dest, IntPtr src, uint count); 
static void Main() 
{ 
    const int size = 200; 
    IntPtr memorySource = Marshal.AllocHGlobal(size); 
    IntPtr memoryTarget = Marshal.AllocHGlobal(size);
    CopyMemory(memoryTarget,memorySource,size); 
}

That leaves me to 2 problems. First of all: How do I assign a memory address to an IntPtr?, kind of like: int* startAddr = &0x00180000.

And secondly: How do I obtain the memory address of a file?

With these two questions answered, my code would look something like:

[DllImport("kernel32.dll", EntryPoint = "CopyMemory", SetLastError = false)]
public static extern void CopyMemory(IntPtr dest, IntPtr src, uint count);
private unsafe void CopyFile()
{
    try
    {
        fixed (Int32* startAddr = /*0x00180000*/)
        {
            fixed(Int32* fileAddr = /*Memory Address of file*/)
            {
                CopyMemory(new IntPtr(startAddr), new IntPtr(fileAddr), (uint)new FileInfo("File name").Length);
            }
        }
    }
    catch { }
}

Would that be a valid way of going about it?

Any help would be greatly appreciated. Thanks in advance!!

Update: CopyMemory is not the way of going about it. So please disregard.

Also, Sorry for not being clearer. Basically I want to move a file to the start of a partition on disk. I thought that IntPtr could also point to a disk address, but in retrospect I can see that of course it can not. Anyway sorry for the confusion.

Answer 1

Files don't have addresses in memory. So what you are asking for is something of a non-sequitur.

So far as I can tell, you don't need any unsafe code at all. You don't need to call CopyMemory. And you don't need to load the entire file in one go and then copy. What you can do is as follows:

1. Use a standard file stream to read the file.
2. Read the file in small chunks into a small buffer. Just to be concrete, you might choose to read the file in 8KB chunks.
3. Each time you read a chunk of the file, copy it to the unmanaged memory location with a call to Marshal.Copy.

The code might look like this:

static void CopyStreamToMemory(Stream stream, IntPtr addr, int bufferSize)
{
    byte[] buffer = new byte[bufferSize];
    long bytesLeft = stream.Length - stream.Position;
    while (bytesLeft > 0)
    {
        int bytesToCopy = (int)Math.Min(bufferSize, bytesLeft);
        stream.Read(buffer, 0, bytesToCopy);
        Marshal.Copy(buffer, 0, addr, bytesToCopy);
        addr += bytesToCopy;
        bytesLeft -= bytesToCopy;
    }
}