C#

Jörgen Sigvardsson wrote:

you can even use Wordpad to print your labels

[StructLayout(LayoutKind.Sequential)]
public struct My_Function_Input_Type
{            
	public UInt32 iSignalCount;                
	public Double[] dSignal;       
	public UInt32 iFilterCount;              
	public Double[] dFilter;
}
[StructLayout(LayoutKind.Sequential)]
public struct My_Function_Return_Type
{
	public UInt32 iDftCount;
	public Double[] dDft;
	public Double[] dFilteredSignal;
}
[DllImport(@"My_DLL.dll")]        
public static extern void My_Funtion(My_Function_Input_Type input, ref My_Function_Return_Type rtrn);

Main()
{
	My_Function_Input_Type input = new My_Function_Input_Type();
	//allocate each variable with a dynamic size variable
            input.dSignal = ReadFile(Raw_TextBox.Text);
            input.iSignalCount = Convert.ToUInt32(input.dSignal.Count());
            input.dFilterKernel = ReadFile(Filter_TextBox.Text);
            input.iFilterCount = Convert.ToUInt32(input.dFilterKernel.Count());

	My_Function_Return_Type rtrn = new My_Function_Return_Type();
	//allocate each variable with a dynamic size variable
	    rtrn.iDftCount = PowerOfTwo(Convert.ToUInt32(input.dSignal.Count()));
            rtrn.dDft = new double[Convert.ToInt32(rtrn.iDftCount)];
            rtrn.dFilteredSignal = new double[Convert.ToInt32(rtrn.iDftCount)];
            
            			
	My_Function(input, ref rtrn);
	
	DoSomethingWithOutput(rtrn);
}

CircuitDoc wrote:

All of the array instantiations is done on the C# side

public int ArrayHandle() {
    int dim=10000;
    int[] numbers=new int[dim];
    ...
    GCHandle handle=GCHandle.Alloc(numbers, GCHandleType.Pinned);
    int sum=SumArray(handle.AddrOfPinnedObject(), dim);
    handle.Free();
    return sum;
}

public struct MY_Input_Type
       {
           public UInt32 iSignalCount;
           public IntPtr dSignal;
           public UInt32 iFilterCount;
           public IntPtr dFilterKernel;
       }

       public struct MY_Return_Type
       {
           public UInt32 iDftCount;
           public IntPtr dDft;
           public IntPtr dFilteredSignal;
       }
       [DllImport(@"MY_DLL.dll")]
       public static extern uint PowerOfTwo(uint b);
       [DllImport(@"MY_DLL.dll")]
       public static extern void FFT_Convolution(MY_Input_Type input, MY_Return_Type rtrn);

       public void Start(string rawFile, string filterFile, string outFile)
       {
           //Instantiate the input and return structs
           MY_Input_Type input;
           MY_Return_Type rtrn;

           //Create arrays to hold the data while in the C# program
           double[] filterData;
           double[] rawData;
           double[] returnData;
           double[] returnFilter;

           //Fill the input arrays with data from files.
           filterData = ReadFile(rawFile);
           rawData = ReadFile(filterFile);

           //Create handles for input arrays so they do not get Garbage collected
           GCHandle rawHandle = GCHandle.Alloc(rawData, GCHandleType.Pinned);
           GCHandle filterHandle = GCHandle.Alloc(filterData, GCHandleType.Pinned);

           //Set the pointers in the input struct equal to the address of the handles for the arrays
           input.dSignal = rawHandle.AddrOfPinnedObject();
           input.dFilterKernel = filterHandle.AddrOfPinnedObject();

           //Initialize input integers to the sizes of the arrays
           input.iFilterCount = Convert.ToUInt32(filterData.Length);
           input.iSignalCount = Convert.ToUInt32(rawData.Length);

           //Set counter in return struct to the size of the return arrays (input size rounded up to power of two)
           rtrn.iDftCount = PowerOfTwo(Convert.ToUInt32(rawData.Length));

           //Initialize the return arrays to the size needed for the return data
           returnData = new double[Convert.ToInt32(rtrn.iDftCount)];
           returnFilter = new double[Convert.ToInt32(rtrn.iDftCount)];

           //Create handles for output arrays so they do not get Garbage collected
           GCHandle rtrnData = GCHandle.Alloc(returnData, GCHandleType.Pinned);
           GCHandle rtrnFilter = GCHandle.Alloc(returnFilter, GCHandleType.Pinned);

           //Set the pointers in the output struct equal to the address of the handles for the arrays
           rtrn.dDft = rtrnData.AddrOfPinnedObject();
           rtrn.dFilteredSignal = rtrnFilter.AddrOfPinnedObject();

           //Call the function, feeding in the structs for the input and return
           FFT_Convolution(input, rtrn);

           //Write the data to a file
           WriteOutput(returnFilter, returnData, outFile);

           //Release Handles to free up the unmanaged memory
           rawHandle.Free();
           filterHandle.Free();
           rtrnData.Free();
           rtrnFilter.Free();
       }

Stark DaFixzer wrote:

I don't want to use The String.Replace

Stark DaFixzer wrote:

I don't want to use The String.Replace