c# BeginUpdateResource

I would like to add a string resource to an executable file programmatically. Just for example purposes, let's say I am trying to add a string named "String SO" which holds the value of "stringVal"

If this helps anyone - if I were to do this through VS.net I could just right click on my Project =>开发者_运维知识库 Resources => Add New String Resource etc..

I am using the following Win32 API's:

[DllImport("kernel32.dll", SetLastError = true)]
public static extern IntPtr BeginUpdateResource(string pFileName,
[MarshalAs(UnmanagedType.Bool)]bool bDeleteExistingResources);

[DllImport("kernel32.dll", SetLastError = true)]
public static extern bool UpdateResource(IntPtr hUpdate, uint lpType, uint lpName, ushort wLanguage, byte[] lpData, uint cbData);

[DllImport("kernel32.dll", SetLastError = true)]
public static extern bool EndUpdateResource(IntPtr hUpdate, bool fDiscard);

So, I have found a couple of pages online but none of them seem to help me in what I am trying to do. If any of you are able to find anything I would be very grateful.

Otherwise, I would greatly appreciate any snippets that may help. Thank you, Evan

There is a very helpful library for many resource-tasks at github.

Many classes and function do wrap those window-api-calls around UpdateResource(...), etc.

Hope that helps.

I'm injecting an application byte[] as a resource to execute it on runtime. Here's my piece of code, hope it helps:

class AddResource
{
    [DllImport("kernel32.dll", SetLastError = true)]
    static extern bool UpdateResource(IntPtr hUpdate, string lpType, string lpName, ushort wLanguage, IntPtr lpData, uint cbData);
    [DllImport("kernel32.dll", SetLastError = true)]
    static extern IntPtr BeginUpdateResource(string pFileName,
       [MarshalAs(UnmanagedType.Bool)]bool bDeleteExistingResources);
    [DllImport("kernel32.dll", SetLastError = true)]
    static extern bool EndUpdateResource(IntPtr hUpdate, bool fDiscard);
private static IntPtr ToPtr(object data)
{
    GCHandle h = GCHandle.Alloc(data, GCHandleType.Pinned);
    IntPtr ptr;
    try
    {
        ptr = h.AddrOfPinnedObject();
    }
    finally
    {
        h.Free();
    }
    return ptr;

}

public static bool InjectResource(string filename, byte[] bytes, string resourceName)
{
    try
    {
        IntPtr handle = BeginUpdateResource(filename, false);
        byte[] file1 = bytes;
        IntPtr fileptr = ToPtr(file1);
        bool res = UpdateResource(handle, resourceName,
            //"RT_RCDATA",
            "0", 0, fileptr, Convert.ToUInt32(file1.Length));
        EndUpdateResource(handle, false);
    }
    catch
    {
        return false;
    }
    return true;

}

public static void CopyStream(Stream input, Stream output,long sz)
{
    // Insert null checking here for production
    byte[] buffer = new byte[sz];

    int bytesRead;
    while ((bytesRead = input.Read(buffer, 0, buffer.Length)) > 0)
    {
        output.Write(buffer, 0, bytesRead);
    }
}

}

Here is how I use it:

using (Stream input = Assembly.GetExecutingAssembly().GetManifestResourceStream("AppLicensing.Resources.SAppStarter.exe"))
                        using (Stream output = File.Create(outputFilePath))
                        {
                            long sz = input.Length;
                            AddResource.CopyStream(input, output, sz);
                        }
                        //inject crypted bytes
                        AddResource.InjectResource(outputFilePath, Encryptor.cryptedbytes, "RT_RCDATA");

And here is how I extract the resource (notice the "RT_RCDATA" -> that s the name of the resource):

   class ReadResource 
    {
        [DllImport("kernel32.dll", CharSet = CharSet.Auto)]
        public static extern IntPtr GetModuleHandle(string lpModuleName);

        [DllImport("kernel32.dll", SetLastError = true)]
        static extern IntPtr FindResource(IntPtr hModule, string lpName, string lpType);

        [DllImport("Kernel32.dll", EntryPoint = "SizeofResource", SetLastError = true)]
        private static extern uint SizeofResource(IntPtr hModule, IntPtr hResource);

        [DllImport("Kernel32.dll", EntryPoint = "LoadResource", SetLastError = true)]

        private static extern IntPtr LoadResource(IntPtr hModule, IntPtr hResource);


       public static  byte[] GetFromResource(String resourceName)
    {
        try
        {
            IntPtr hModule = GetModuleHandle(System.Diagnostics.Process.GetCurrentProcess().MainModule.ModuleName);
            IntPtr loc = FindResource(hModule, "0", resourceName);
            uint size = SizeofResource(hModule, loc);
            IntPtr x = LoadResource(hModule, loc);
            byte[] bPtr = new byte[size];
            Marshal.Copy(x, bPtr, 0, (int)(size));
            return bPtr;
        }
        catch (Exception e)
        {
            System.Windows.Forms.MessageBox.Show(e.ToString());
            System.Environment.Exit(0);
            return null;
        }        
    }            
  }

  byte[] encryptedData = ReadResource.GetFromResource("RT_RCDATA");

The code gets a bit messy... hope this helps.

Although the author is dealing with his own issue right now, the SO question UpdateResource function fails has code snippet for using these calls.

The code from Samson work with String lpType, that mean you can't actually add RT_RCDATA resource either reading from it, it's only create and read lpType named "RT_RCDATA" only. If you want it to read real RT data you'll need to modify lpType from string to uint and this is RT API table:

private const uint RT_CURSOR = 0x00000001;
private const uint RT_BITMAP = 0x00000002;
private const uint RT_ICON = 0x00000003;
private const uint RT_MENU = 0x00000004;
private const uint RT_DIALOG = 0x00000005;
private const uint RT_STRING = 0x00000006;
private const uint RT_FONTDIR = 0x00000007;
private const uint RT_FONT = 0x00000008;
private const uint RT_ACCELERATOR = 0x00000009;
private const uint RT_RCDATA = 0x0000000a;
private const uint RT_MESSAGETABLE = 0x0000000b;