Sharing Variables Between C# and C++

Sharing variables between C# and C++

There is no problem sharing memory between C# and C++ using P/Invoke once you know how it works. I would suggest reading about marshaling in MSDN. You might also want to read about using the unsafe keyword and fixing memory.

Here is a sample that assumes that your variables can be described as a simple struct:

In C++ declare your function as follows:

#pragma pack(1)
typedef struct VARIABLES
{
/*
Use simple variables, avoid pointers
If you need to use arrays use fixed size ones
*/
}variables_t;
#pragma pack()
extern "C"
{
     __declspec(dllexport) int function1(void * variables)
    {
        // some work depending on random and on the "variables"
    }
}

In C# do something like this:

[StructLayout(LayoutKind.Sequential, Pack=1)]
struct variables_t
{
/*
Place the exact same definition as in C++
remember that long long in c++ is long in c#
use MarshalAs for fixed size arrays
*/
};

[DllExport("YourDll.dll", CallingConvention=CallingConvention.Cdecl)]
static extern int function(ref variables_t variables);

And in your class:

variables_t variables = new variables_t();
//Initialize variables here
for(int i=0; i<many_times; i++)
{
    int[] result = new int[number_of_parallel_tasks];
    Parallel.For(0, number_of_parallel_tasks, delegate(int j)
    { 
          result[j] = function1(ref variables)  
    });

    //  choose best result
    //  then update "variables" 
}

You can use more complex scenarios like allocating and releasing the structure in c++, using other forms of marshaling to get the data back like building your own class to read and write directly to the unmanaged memory. But if you can use a simple struct to hold your variables the method above is the simplest.

EDIT: Pointers on how to handle correctly more complex data

So the sample above is in my opinion the correct way to "share" data between C# and C++ if it is simple data eg. a structure holding primitive types or arrays of fixed size of primitive types.

This being said there are actually very little limitations on the way you can access memory using C#. For more information look into the unsafe keyword, the fixed keyword and the GCHandle struct. And still if you have a very complex data structures that contain arrays of other structures etc. then you have a more complicated job.

In the case above I would recommend moving the logic on how to update the "variables" into C++.
Add in C++ a function to look something like this:

extern "C"
{
     __declspec(dllexport) void updateVariables(int bestResult)
    {
        // update the variables
    }
}

I would still suggest not to use global variables so I propose the following scheme.
In C++:

typedef struct MYVERYCOMPLEXDATA
{
/*
Some very complex data structure
*/
}variables_t;
extern "C"
{
     __declspec(dllexport) variables_t * AllocVariables()
    {
        // Alloc the variables;
    }
     __declspec(dllexport) void ReleaseVariables(variables_t * variables)
    {
        // Free the variables;
    }
     __declspec(dllexport) int function1(variables_t const * variables)
    {
        // Do some work depending on variables;
    }
    __declspec(dllexport) void updateVariables(variables_t * variables, int bestResult)
    {
       // update the variables
    }
};

In C#:

[DllExport("YourDll.dll", CallingConvention=CallingConvention.Cdecl)]
static extern IntPtr AllocVariables();
[DllExport("YourDll.dll", CallingConvention=CallingConvention.Cdecl)]
static extern void ReleaseVariables(IntPtr variables); 
[DllExport("YourDll.dll", CallingConvention=CallingConvention.Cdecl)]
static extern int function1(IntPtr variables); 
[DllExport("YourDll.dll", CallingConvention=CallingConvention.Cdecl)]
static extern void updateVariables(IntPtr variables, int bestResult);

If you still want to maintain you logic in C# you will have to do something like the following:
Create a class to hold the memory returned from C++ and write your own memory access logic. Expose the data to C# using copy semantics. What I mean is as follows,
Say you have in C++ a structure like this:

#pragma pack(1)
typedef struct SUBSTRUCT
{
int subInt;
double subDouble;
}subvar_t;
typedef struct COMPLEXDATA
{
int int0;
double double0;
int subdata_length;
subvar_t * subdata;
}variables_t;
#pragma pack()

in C# you do something like this

[DllImport("kernel32.dll")]
static extern void CopyMemory(IntPtr dst, IntPtr src, uint size);

[StructLayout((LayoutKind.Sequential, Pack=1)]
struct variable_t
{    
    public int int0;
    public double double0;
    public int subdata_length;
    private IntPtr subdata;
    public SubData[] subdata
    {
        get
        {
             SubData[] ret = new SubData[subdata_length];
             GCHandle gcH = GCHandle.Alloc(ret, GCHandleType.Pinned);
             CopyMemory(gcH.AddrOfPinnedObject(), subdata, (uint)Marshal.SizeOf(typeof(SubData))*subdata_length);
             gcH.Free();
             return ret;
        }
        set
        {
             if(value == null || value.Length == 0)
             {
                 subdata_length = 0;
                 subdata = IntPtr.Zero;
             }else
             {
                 GCHandle gcH = GCHandle.Alloc(value, GCHandleType.Pinned);
                 subdata_length = value.Length;
                 if(subdata != IntPtr.Zero)
                     Marshal.FreeHGlobal(subdata);
                 subdata = Marshal.AllocHGlobal(Marshal.SizeOf(typeof(SubData))*subdata_length);
                 CopyMemory(subdata, gcH.AddrOfPinnedObject(),(uint)Marshal.SizeOf(typeof(SubData))*subdata_length);
                 gcH.Free();
             }
        }
    }
};
[StructLayout((LayoutKind.Sequential, Pack=1)]
sturct SubData
{
    public int subInt;
    public double subDouble;
};

In the above sample the structure can still be passed as in the first sample. This of course is just an outline on how to handle complex data with araays of structures and arrays of structures within arrays of structures. As you can see you will need a lot of copying to guard yourself from memory corruption. Also if the memory is allocated via C++ it will be very bad if you use FreeHGlobal to free it.
If you want to avoid copying memory and still maintain the logic within C# the you can write a native memory wrapper with accessors for what ever you want For instance you will have a method to directly set or get the subInt of Nth array member - This way you will keep your copies to exactly what you access.

Another option would be to write specific C++ functions to do the difficult data handling for you and call them from C# according to your logic.

And last but not least you can always use C++ with CLI interface. However I myself do it only if I must - I don't like the lingo but for very complex data you certainly have to consider it.

EDIT

I added the correct calling convention to the DllImport for completeness. Please note that the default calling convention used by the DllImport attribute is Winapi (which on windows translates to __stdcall) while the default calling convention in C/C++ (unless you change the compiler options) is __cdecl.

Sharing c# variables between methods?

There are a couple of options. Since these methods are event handlers and aren't directly invoked, the best approach here is likely to make the variable class-level members:

private string strHeaderFileName;

protected void multiFileUpload_FileUploaded(object sender, FileUploadedEventArgs e)
{
    strHeaderFileName = e.File.FileName;
    // etc.
}

protected void btnSave_Click(object sender, EventArgs e)
{
    // here you can access strHeaderFileName
}

As class-level members, they will be accessible by any method in that class. (Make sure you keep them private or other objects will be able to access them too, which you probably don't want in this case.) And they will exist for the lifetime of any given instance of that class.

Also note that this looks like ASP.NET, which behaves a little differently in terms of class instances than things like WinForms. Any given instance of a Page doesn't persist between requests. So if you set the value in one handler, display the page again, and then invoke another handler the value won't be there anymore. This is because the class instance for each Page is created per-request and then destroyed after the response.

To persist across page requests, you'd need to keep the value somewhere else. For example, if it needs to live during the scope of that user's session then you can put it in session state:

protected void multiFileUpload_FileUploaded(object sender, FileUploadedEventArgs e)
{
    Session["strHeaderFileName"] = e.File.FileName;
    // etc.
}

protected void btnSave_Click(object sender, EventArgs e)
{
    // here you can access Session["strHeaderFileName"]
}

Depending on the scope in which the value needs to persist, you could also put it on the page, in a cookie, in a database, some caching mechanism, etc.

sharing variables between running applications in C#

You need some sort of mechanism to communicate between the applications.

This can be through the registry, files, memory mapped files etc...

If both applications are expected to do write, you need to add synchronization logic to your code.

Sharing variable between C# and C

I will be using a named pipe so the two processes can communicate together easily! (C# server and C++ Client)

Thanks for the help everyone!

C# share or modify variables between classes

If you set a static class it is possible to do what you want to.

public static class Timers
{
    public static DateTime lastInteraction { get; set; }
    ...
}

And in the KeyHook class you can put values on it.

public static IntPtr HookCallback(int nCode, IntPtr wParam, IntPtr lParam)
{
    if (nCode >= 0 && wParam == (IntPtr)WM_KEYDOWN)
    {
        int vkCode = Marshal.ReadInt32(lParam);
        >>>>>Timers.lastInteraction = DateTime.Now;
        Console.WriteLine((Keys)vkCode);
    }
    return CallNextHookEx(_hookID, nCode, wParam, lParam);
}

And you can access the value of Timers.lastInteraction on all namespace range at runtime.

How do I pass variables between methods in C#?

Your example has a Form named Form1 that has a Button named button1, a TextBox named textbox1 and a Label named label1.

The scenario you are attempting is:

user enters some text into textbox1
user clicks on button1, this will save the current value from textbox1
user clicks on label1, this will display the value that was stored in the previous step

It is important to understand that in this scenario we are not trying to pass a value between 2 methods because the button click and the label click can occur independently of each other, so really this is like the memory store (M+) and memory recall (MR) buttons on calculator.
To achieve this storage you should create an instance variable (sometimes referred to as a member variable) on the Form1 class, this will be accessible to the other methods on the same instance of the Form1 class.

See Working with Instance and Local variables for a practical explanation

Create a field or a property to store the value, for your specific example either would work, however to become familiar with C# techniques I would recommend you start with a property, as that better encapsulates your scenario of storing the value for later use and later to potentially augment how and where the value is actually stored.
See What is the difference between a field and a property?
for a healthy discussion

Until you need to change the implementation, you can simply use an Auto-Property
```
 public string StoredText { get; set; }
```
Now in the click event handler of button1 we can set the value of the StoredText property on the Form1 instance
```
 private void button1_Click(object sender, EventArgs e)
 {
     this.StoredText = textBox1.Text;
 }   
```
set is a term we use for saving a value into a property in c#
Note the use of the this keyword, it is optional in this case, or can be inferred by the compliler, it indicates that we want to reference a member on the instance of the class, not a variable that might have the same name within the same method scope of the line of code that is executing.
Finally in the click event handler of label1 we can get the value that was previously stored in the StoredText property in the Form1 instance.
```
 private void label1_Click(object sender, EventArgs e)
 {
     // Get the "StoredText" variable and use it
     label1.Text = this.StoredText;
 }
```
get is a term we use for accessing a value from a property in c#
this is not required, but can be helpful to understand that we are accessing a member that is outside of the current method scope.

Together this looks something like:

namespace Example
{
    public partial class Form1 : Form
    {
        public Form1()
        {
            InitializeComponent();
        }

        /// <summary>Saved value from see <see href="textBox1"/></summary>
        public string StoredText { get; set; }

        private void button1_Click(object sender, EventArgs e)
        {
            this.StoredText = textBox1.Text;
        }

        private void label1_Click(object sender, EventArgs e)
        {
            // Get the "StoredText" variable and use it
            label1.Text = this.StoredText;
        }
    }
}

What you may not have noticed is that textBox1 and label1 are themselves infact instance variables that are initialized in a separate code file when InitializeComponent() is executed in the constructor.
For this reason you do not need to store the value at all and you could simply re-write the client event handler for button1 to write directly to label:

label1.Text = textBox1.Text;

It is possible to pass variables directly between methods without an intermediary store, this is a lesson for another day and will involve return statements and/or parameters on your methods.
In this scenario however, neither return or additional parameters on these methods cannot be used because these are event handlers that need a specific method signature to operate as expected.

Sharing Variables Between C# and C++