关于matlab与c#混合编程的问题

227/// An application should only call this method when required to keep the

228/// MATLAB figure window from disappearing. Other techniques, such as calling 229/// Console.ReadLine() from the application should be considered where 230/// possible. 231///

232publicvoid WaitForFiguresToDie() 233 {

234 mcr.WaitForFiguresToDie(); 235 } 236 237 238

239#endregion Methods 240

241#region Class Members 242

243privatestatic MWMCR mcr= null; 244

245privatebool disposed= false; 246

247#endregion Class Members 248 } 249 }

对比大家就可以发现，只不过一个更加傻瓜化，参数都是Object了，其实这样反而不好，增加了类型转换的代价，如果知道，为何不给一个正确的给他呢。关于这2个dll的速度，曾经听说过是有差别的，博客园有人给过测试，我没实际测试过，还是习惯用传统的TestDemo.cs，因为参数类型都是Object，不直观，出了问题也有点头疼。

2.4 上述Matlab自动生成代码的要点

后面某些类或者方法的XML注释就不说了，自动生成的东西，可以对照M文件的注释来看。

1.首先看第一段的注释信息：

1/*

2* MATLAB Compiler: 4.17 (R2012a) 3* Date: Mon Sep 09 16:19:01 2013

4* Arguments: \\ 5* \

\

6* \ 7* \\ 8* \

\\ 9*/

10using System;

11using System.Reflection; 12using System.IO;

13using MathWorks.MATLAB.NET.Arrays; 14using MathWorks.MATLAB.NET.Utility;

上面这段信息主要是说明当前Matlab编译器的版本，因为编译的版本和部署的MCR版本必须对应起来，否则是不能运行的。然后有编译日期，以及编译的参数，类名以及M函数的地址等信息，其实知道这些参数，理论上是可以自己在程序里面调用Matlab的编译器进行编译工作的，只不过比较复杂，能力有限，研究不下去。下面的引用大家应该明白，这个是MWArray.dll里面的命名空间，所以混编的项目都要引用对应版本的MWArray.dll

2.关键的静态构造函数

1static TestDemo() 2 {

3if (MWMCR.MCRAppInitialized) 4 {

5 Assembly assembly= Assembly.GetExecutingAssembly(); 6string ctfFilePath= assembly.Location;

7int lastDelimiter= ctfFilePath.LastIndexOf(@\);

8 ctfFilePath= ctfFilePath.Remove(lastDelimiter, (ctfFilePath.Length - lastDelimiter)); 9string ctfFileName = \;

10 Stream embeddedCtfStream = null; 11 String[] resourceStrings = assembly.GetManifestResourceNames();

12foreach (String name in resourceStrings) 13 {

14if (name.Contains(ctfFileName)) 15 {

16 embeddedCtfStream =

assembly.GetManifestResourceStream(name); 17break;

18 } 19 }

20 mcr= new MWMCR(\,ctfFilePath, embeddedCtfStream, true); 21 } 22else

23 {

24thrownew ApplicationException(\initialized\); 25 } 26 }

如果有一些C#的开发和编程经验看上面的代码问题应该不大，否则还真有点难说清楚，简单的说几个要点：

1）这个构造函数的作用主要是检测MCR对象是否初始化，如果没有，则寻找程序集，并拼接资源的位置，正确进行初始化

2) 上面的ctf其实是包含在dll程序集里面的，以资源的形式，这个文件是核心，它才真正的包括了Matlab编译之后的，MCR可以运行的中间程序。

3) 必须要合法正确的ctf文件和dll文件才能 正确的初始化mcr对象，合法的意思，是Matlab内部有校验机制，包括对相关版本，在以前的版本生成文件中，很明显，现在2012a里面都隐藏起来了，不过要求都一样。

4) 上面方法其实已经间接的告诉了我们怎么初始化mcr对象，有了mcr对象，一切都好办了，因为它才是MCR的核心。

3.PlotTest封装的方法代码

1publicvoid PlotTest() 2 {

3 mcr.EvaluateFunction(0, \, new MWArray[]{}); 4 }

5publicvoid PlotTest(MWArray n) 6 {

7 mcr.EvaluateFunction(0, \, n); 8 }

9public MWArray[] PlotTest(int numArgsOut) 10 { 11return mcr.EvaluateFunction(numArgsOut, \, new MWArray[]{}); 12 }

13public MWArray[] PlotTest(int numArgsOut, MWArray n) 14 {

15return mcr.EvaluateFunction(numArgsOut, \, n); 16 }

看了字段代码，再对应mcr的初始化，其实都很明朗了。通过mcr的EvaluateFunction来调用M函数。上面的代码有几个重载方法，可以实用很多不同的情况，有时候，这些方法的个数会更多，其实没多大必要，也可以自己编译一下，把没用的删掉，保留少数几个有用的即可。同时也可以看到，这里直接通过字符串来传递函数名称的，因此必须保证这个函

数能被mcr搜索到。比如我们这里的\这个函数其实就包含了ctf文件中（注意ctf文件是可以和dll分开的，在混编项目里可以设置）。

回到目录

3.上述代码到内置函数的调用

上述已经讲解了整个mcr调用的过程，其实就是通过mcr的EvaluateFunction来调用M函数，但要保证对于的函数名称在mcr搜索的范围内。那么我们是不是可以假设：内置函数都在MCR内部，应该是可以搜索到的，那么把上面的函数名称换一下，是不是也是可行的。这个假设也是我最早接触时候的想法，有了假设，当然要去验证。现在看来这个当然是肯定的，那么不妨重新演示一遍。过程不详细讲了，代码也有注释，混编要引用的MWArray.dll和命名空间也不提了，看代码：

1using System;

2using System.Collections.Generic; 3using System.Linq; 4using System.Text;

5using System.Reflection; 6using System.IO; 7

8using MathWorks.MATLAB.NET.Utility; 9using MathWorks.MATLAB.NET.Arrays; 10 11

12namespace BuildInFunctionDemo 13 {

14class Program 15 {

16static MWMCR mcr;

17staticvoid Main(string[] args) 18 {

19#region 首先使用PlotTest.dll来初始化mcr,因为这个dll是混编“合法”产生的，只有这样才能顺利启动mcr

20if (MWMCR.MCRAppInitialized) 21 {

22string path = Path.Combine(System.Environment.CurrentDirectory, \);

23 Assembly assembly = Assembly.LoadFile(path); 24string ctfFilePath = assembly.Location;

25int lastDelimiter = ctfFilePath.LastIndexOf(@\);

26 ctfFilePath = ctfFilePath.Remove(lastDelimiter, (ctfFilePath.Length - lastDelimiter)); 27string ctfFileName = \;

28 Stream embeddedCtfStream = null; 29 String[] resourceStrings = assembly.GetManifestResourceNames(); 30

31foreach (String name in resourceStrings) 32 {

33if (name.Contains(ctfFileName)) 34 {

35 embeddedCtfStream = assembly.GetManifestResourceStream(name); 36break;

37 } 38 }

39 mcr = new MWMCR(\,ctfFilePath, embeddedCtfStream, true);

40 } 41else

42 {

43thrownew ApplicationException(\initialized\); 44 } 45#endregion 46

47#region 直接调用混编dll中的封装函数进行测试

48 mcr.EvaluateFunction(0, \, 5); 49

50//注意这里要断点调试才能看到效果哦，因为mcr会把图绘制在一个Figure上面，

51//后面的会覆盖前面的，这里暂停一下，可以看前面的效果 52//下面就是直接调用matlab的plot函数的效果

53 MWNumericArray x = newdouble[]{1,2,3,4,5};

54 MWNumericArray y = newdouble[]{2,1,2.8,5.3,4.7}; 55 mcr.EvaluateFunction(0, \,x,y ); 56#endregion

57

58 Console.ReadKey(); 59 } 60 } 61 }

唯一要注意的就是50-52的说明，要加断点看2次绘制的效果。分别截图如下：

= 回到目录

4.总结

抛砖引玉，这里只是一个思路，附代码下载吧。

Multiple Inputs and Outputs in Builder NE Type Safe APIs

Posted by Loren Shure, June 30, 2011 Guest blogger Peter Webb returns with another in an occasional series of postings about application deployment. Contents ? ? ? ? Multiple Arguments with Varying Types

Overloaded Functions and Parameter Order in a C# Interface Building and Running the Example Flexibile or Complicated? Multiple Arguments with Varying Types I've got a MATLAB function with multiple inputs and outputs that I'd like to call from C#. Though that may not seem like much of a challange, MATLAB processes function arguments very differently from C#, particularly optional arguments and multiple return values. The behavior of my MATLAB function, polygonal, depends on both the number and types of the inputs. polygonal computesthree different number sequences. Given an integer N for each sequence, it returns the Nth entry in each sequence. Only the first input (tN) is required; the other two are optional. function [t, p, h] = polygonal(tN, pN, hN) In typical MATLAB fashion, if any input is a vector of length K, polygonal returns K elements of that sequence. For each sequence, the numeric type of the input determines the numeric type of the output. If tN is int32, for example, polygonalreturns an int32 t. That's a lot of complexity wrapped up in a single function line. I count at least 36 different ways to call polygonal. How do we manage this complexity in C#? In a word: overloading. Overloaded Functions and Parameter Order in a C# Interface Generally speaking, a function is overloaded if you can call it with different numbers or types of inputs and outputs. In C#, you must write a new function for each set of inputs and outputs. I've implemented five of polygonal's 36 overloads in C# to demonstrate how Builder NE matches C# function declarations to MATLAB functions. The simplest of polygonal's overloads consists of one scalar double input and one scalar double output. In C#: double polygonal(double t); Builder NE maps the first C# input, t to the first MATLAB input (tN, and note the names of the arguments are not considered in the matching process), and the first MATLAB output (t) to the C# function's return value.

Next, I'll declare a function to call polygonal with three scalar inputs, which produces three scalar outputs. Since C# does not permit multiple return values, Builder NE supports C# out parameters in their place. void polygonal(out double t, out double p, out double h, double tN, double pN, double hN); In this function, the outputs appear first, followed by the inputs, and the return type is void. This form is perhaps closest to the structure of the MATLAB function, but Builder NE supports many others. You may map the first MATLAB output to the C# function's return value:

double polygonal(out double p, out double h, double tN, double pN, double hN); out t has vanished, and the return type changed from void to double.

You may also interleave (mix) inputs and outputs. Here, I've placed each input before the output it produces:

void polygonal(double tN, out double t, double pN, out double p, double hN, out double h); Finally, remember that polygonal supports vector inputs and and outputs; here I've requested double[] vector outputs from from double[] vector inputs. In this function the outputs again appear before the inputs, as that's the style I prefer. void polygonal(out double[] t, out double[] p, out double[] h, double[] tN, double[] pN, double[] hN); Building and Running the Example

First, download the source code for this article from MATLAB Central.

As usual, the process of invoking polygonal through a type safe API consists of three steps: ? Build the IFigurate interface DLL.

? Create the Generator .NET assembly and the GeneratorIFigurate type safe interface. ? Compile the main program, PolySeq, after referencing IFigurate and GenerateIFigurate in the PolySeq project.

The file ReadmeParameters.txt contains detailed instructions. Make sure your runtime environment is set up correctly, and then

run PolySeq\\PolySeq\\bin\\Debug\\PolySeq.exe. It callspolygonal through several of the C# interfaces described above and produces the following output:

The 17th triangular number: 153 The 13th triangular number: 91 The 11th pentagonal number: 176 The 19th hexagonal number : 703 Polygonal Numbers N: 3 6 9 ----------------------- Triangular: 6 21 45 Pentagonal: 12 51 117 Hexagonal : 15 66 153 You can generate the same numbers in MATLAB with three calls to polygonal: % 17th triangular number t = polygonal(17); % 13th triangular, 11th pentagonal and 19th hexagonal numbers [t, p, h] = polygonal(13, 11, 19); % 3rd, 6th, and 9th triangular, pentagonal and hexagonal numbers order = [3, 6, 9]; [t, p, h] = polygonal(order, order, order); Flexibile or Complicated?

What do you think of the parameter ordering and function overloading rules? Some of them were dictated by the structure of C# and MATLAB, but some resulted from usability testing and our design judgement. Are they too complicated, or just flexible enough? Let me know here.

Introducing Type Safe APIs with Builder NE 8Posted by Loren Shure, June 3, 2011

Guest blogger Peter Webb returns with another in an occasional series of postings about application deployment.

Contents

? ? ? ? ?

Life is Too Short to Write Boring Code Type Safe APIs Example C# Code

Building and Running the Example More to Come

Life is Too Short to Write Boring Code

I can call MATLAB functions from C# using Builder NE. But MATLAB and C# have very different data types, so I spend a lot of time manually converting data from one system to the other. That kind of work is tedious and error-prone -- the C# compiler can't check to ensure that I'm passing the right type of data to my MATLAB functions.

Ideally, I'd like to be able to write MATLAB code that uses MATLAB data types and C# code that uses C# data types, and not have to worry about the conversion between them. Consider a very simple example, a MATLAB multiply function: function z = multiply(x, y) z = x * y; Though it looks simple, multiply behaves very differently depending on the type of its inputs. If the inputs are scalars, the result is a scalar, but if they are matrices, the result is the matrix product. And the numeric data type of the output (int32, double) varies with the type of the input.

In C#, I'd like to call multiply with scalars and matrices, and additionally to to support scalars times vectors. That's three ways to call multiply, and in C#, that means three separate functions: double multiply(double x, double y) // Scalar double[,] multiply(double[,] x, double[,] y) // Matrix double[] multiply(double[] x, double y) // Vector x Scalar So far, that's nothing new -- I can do this today. I write each of these multiply functions myself, filling them up with code that converts .NET scalars, vectors and arrays to MATLAB matrices and vice versa. But it's boring, and I hate being bored.

So instead, I turn to the type safe APIs generated by Builder NE (as of version 4.0, R2011a), and let Builder NE write this code for me.

Type Safe APIs

Type Safe APIs allow you to specify a kind of contract between your C# code and your MATLAB functions. You describe exactly what kind of data you want to pass back and forth between MATLAB and C#, and Builder NE generates functions for those types only. You give up a little flexiblity (you can't pass just any type of data to your MATLAB function, like you could with the MWArray-based interface), but you gain type safety. Now the C# compiler can tell if you're doing something you shouldn't be, like passing strings to a function that operates on integers. (While this often completes without error, it very seldom produces a useful result.)

In C#, the usual mechanism for establishing such a contract is an interface. An interface defines the names and input and output types of one or more functions, but provides no implemention. We can collect our

three multiply functions into the IMultiplyinterface. By convention, .NET interface names begin with a capitial I.

interface IMultiply { // Scalar multiplication double multiply(double x, double y); // Multiply vector by a scalar, return a vector double[] multiply(double[] x, double y); // Matrix multiplication double[,] multiply(double[,] x, double[,] y); } The interface uses function overloading to take advantage of the polymorphism of the MATLAB function. The functions in the C# interface have the same name as the MATLAB function; Builder NE matches interface functions to MATLAB functions by name and number of arguments. (I'll discuss the details of argument matching in a later article.) To use a type safe API, you'll need:

? ? ?

A MATLAB function

A C# interface that specifies the input and output types of that MATLAB function A C# program that calls the MATLAB function through the C# interface.

The example demonstrates how to incorporate a type safe API into a C# program. In the example, you'll work through 4 basic steps:

? Create a MATLAB function, multiply. ? Define a C# interface IMultiply.

? Compile multiply into a .NET component named Multiply and generate the type safe API MultiplyIMultiply.

? Develop a C# main program that calls multiply through the IMultiply interface.

Since we've already seen the MATLAB code and the C# interface, let's take a look at the C# main program.

Example C# Code

You invoke MATLAB functions from C# by calling the instance methods of a Builder NE-generated component. Builder NE names the type safe API class by combining the names of the MATLAB function component (Multiply) and the C# interface (IMultiply). In this case, MultiplyIMultiply is the name of the type safe API class. Call new to create an instance of the component's type safe API class: // Create an instance of the Multiply component's type safe API. IMultiply m = new Multiply.MultiplyIMultiply(); IMultiply publishes three multiply methods, one of which multiplies a vector and a scalar. Create the input data by declaring C# variables:

// Create a C# vector and a scalar. double[] v = new double[]{ 2.5, 81, 64 }; double s = 11; Finally, compute the product by calling multiply:

// Multiply the vector and the scalar. Note: all inputs and outputs // are native C# types. double[] d = m.multiply(v, s); As usual in C#, passing the wrong type of inputs (if v had been declared as a string for example) results in compile-time errors.

Building and Running the Example

Download the source code from MATLAB Central into a new directory. The download contains

the multiply MATLAB function and two Visual Studio projects. To create a runnable executable, you need to build the C# interface assembly, create adeploytool .NET assembly project for the MATLAB function and then link the main program against these two assemblies. The file ReadmeIntro.txt contains detailed instructions.

The downloaded files compile into Multiplier.exe, a C# program that calls each of the methods in the IMultiply interface and prints the results. Make sure your runtime environment is set up correctly (you need either the MCR or MATLAB'sruntime/ directory on your path) and then locate and run Multiplier.exe from a DOS command window. The output should look something like this: 17 * 3.14159 = 53.40703 [ 2.5 81 64 ] * 11 = [ 27.5 891 704 ] 8 1 6 8 1 6 91 67 67 3 5 7 * 3 5 7 = 67 91 67 4 9 2 4 9 2 67 67 91 To enable other types of multiplcation, say vector times matrix or matrix times scalar, define the appropriate methods inIMultiply and then regenerate the Multiply component.

More to Come

To keep this post from turning into a book, I've discussed only the simplest and most common uses of Builder NE's type safe APIs. Forthcoming articles will reveal the secrets of parameter ordering, address the use of structured types (cell arrays and structures), and demonstrate how type safe APIs enable interprocess communication through the Windows Communication Foundation.

In the meantime, please let me know what you think of this new feature. Will it make your job easier? How could we improve it even futher? Let us know here.

Get the MATLAB code

Published with MATLAB? 7.12

Category:

Deployment

? ? ? ? ? ? ?

Tweet

< Transferring Data Between Two Computers...

Calculating the Area Volume Under... > You can follow any comments to this entry through the RSS 2.0 feed. Both comments and pings are currently closed.

8 CommentsOldest to Newest

Alexandre Kozlov replied on June 3rd, 2011 6:23 pm UTC :1 of 8

Isn’t it possigble just to introduce a datatypes for MatLab variables? With – for backward compatibility – a generic default type (like Variant in VBA). This will help MathWorks to implement a lot of another features to resolve a lot of my problems like:

1. Auto code completion. Espetially with my own classes – I’d like to see all methods of the corresponding class after typing a variable name followed by a dot.

2. Auto doc generation. Espetially for dependency reports (today it’s impossible to know what class will be passed as a parameter for my function).

3. Methods overloading. Often I’d like to have two methods – just like in your exemple, the same name, the same parameters, but depending of their types, I want to write different function’s bodies. Today I have to write myself a function’s header to determine a case I’m in, and to call one of more specific functions (with strange names instead of the same name – as they do the same thing). 4. Etc., etc.

Joan replied on June 4th, 2011 6:02 pm UTC :2 of 8 Hi,

That sounds really interesting. Any hope to get something similar for Java? Joan

Ben Schmitt replied on June 6th, 2011 1:55 pm UTC :3 of 8

The new feature looks very useful for our applications, I look forward to reading more about it.

I also couldn’t agree more with Alexandre, it would be attractive to have the option of type-explicit m-code, equivalent to VBA’s “Option Explicit”.

Peter Webb replied on June 6th, 2011 5:10 pm UTC :4 of 8 Joan,

We’re definitely thinking about it. But I can’t say that we’ll do it, or if we do, when it might ship. :-)

Peter Webb replied on June 6th, 2011 5:15 pm UTC :5 of 8 Alexandre and Ben,

We’ve been thinking about this for at least a decade, but haven’t come up with a good design yet. It’s a real challenge balancing the ease-of-use and performance trade-offs. For now, the deployment tools are going to limit themselves to managing types at the interface between MATLAB and external execution environments like Microsoft .NET.

owr replied on June 6th, 2011 11:25 pm UTC :6 of 8

Thanks for the example – I am really enjoying the new features in Builder NE. I would love to see some good examples of using the MWObjectArray coupled with .NET External Interfaces to deploy MATLAB functions that return custom C# objects.

Peter Webb replied on June 7th, 2011 3:49 pm UTC :7 of 8

owr,

The type safe APIs will allow you to return custom C# structures from MATLAB functions. (The C# field names have to match the MATLAB field names.) Objects are trickier, because they have methods.

What exactly are you looking for? Automatic generation of a C# object that acts as a proxy for a MATLAB object? Automatic initialization of a C# object from a MATLAB structure? Or something else entirely?

Patrick replied on September 6th, 2011 10:13 am UTC :8 of 8 Loren, Peter,

Good to see that you are improving the Matlab Builder NE.

Conversion of data between Matlab and C# causes a lot of programming and maintenance overhead in our application, so I would love to use the new Type-Safe API.

I’ve tried the Type-Safe API creation to see if we could use it in our application. Some comments:

* Automatic conversion is supported for structs, not objects. Unfortunately this does not lead to a workable solution for us: Structs are not preferred in due to their limitations (eg. being sealed).

* The DeployTool can only generate one TypeSafeAPI per project. We have separated our interface with Matlab into 4 classes. It appears that for this to work we would have to split our interface into 4 seperate assemblies, and 4 TypeSafeAPI assemblies.

Because of the above reasons we will not yet use the TypeSafeAPI functionality. However, using the new Builder NE provides two good additions for us: * the method MWArray.ConvertToNativeTypes() * the MwObjectArray

In the past we have created our own data conversion utilities to maintain readability of our calls to Matlab, and create reusable wrapping code.

These utilities use reflection to map custom .Net objects to MwStructArrays. Due to the above mentioned two additions we were already able to reduce the code for our own conversion utilities by 50%! Hope to see more of these improvements in future releases!

These postings are the author's and don't necessarily represent the opinions of MathWorks.

%% Multiple Inputs and Outputs in Builder NE Type Safe APIs % Guest blogger

% returns with another in an

%

本文来源：https://www.bwwdw.com/article/qvlw.html