|
|
|
| R2012a Documentation → MATLAB Builder NE | |
Learn more about MATLAB Builder NE |
|
| Contents | Index |
| On this page… |
|---|
.NET Developer
| Role | Knowledge Base | Responsibilities |
|---|---|---|
 .NET
Developer |
|
|
After you create the remotable component, you can set up a console server and client using the MWArray API. For more information on choosing the right API for your access needs, see Selecting the Best Method of Accessing Your Component: MWArray API or Native .NET API.
Some reasons you might use the MWArray API instead of the native .NET API are:
You are working with data structure arrays, which the native .NET API does not support.
You or your users work extensively with many MATLAB data types.
You or your users are familiar and comfortable using the MWArray API.
For information on accessing your component using the native .NET API, see Using the Native .NET API: Magic Square Example.
The server application hosts the remote component built in Creating a Remotable .NET Component. You can also perform these steps using the MWArray API (see Using the Native .NET API: Magic Square Example).
The client application, running in a separate process, accesses the remote component hosted by the server application. Build the server using the Microsoft Visual Studio project file MagicSquareServer\MagicSquareMWServer.csproj:
Change the references for the generated component assembly to MagicSquareComp\distrib\MagicSquareComp.dll.
Select the appropriate build platform.
Select Debug or Release mode.
Build the MagicSquareMWServer project.
Supply the configuration file for the MagicSquareMWServer.
MagicSquareServer Code. Use the C# code for the server located in the file MagicSquareServer\MagicSquareServer.cs:
using System;
using System.Runtime.Remoting;
namespace MagicSquareServer
{
class MagicSquareServer
{
static void Main(string[] args)
{
RemotingConfiguration.Configure
(@"..\..\..\..\MagicSquareServer.exe.config");
Console.WriteLine("Magic Square Server started...");
Console.ReadLine();
}
}
}
This code does the following processing:
Reads the associated configuration file to determine
The name of the component that it will host
The remoting protocol and message formatting to use
The lease time for the remote component
Signals that the server is active and waits for a carriage return to be entered before terminating.
MagicSquareServer Configuration File. The configuration file for the MagicSquareServer is in the file MagicSquareServer\MagicSquareServer.exe.config. The entire configuration file, written in XML, follows:
<?xml version="1.0" encoding="utf-8" ?>
<configuration>
<system.runtime.remoting>
<application>
<service>
<wellknown mode="SingleCall"
type="MagicSquareComp.MagicSquareClass, MagicSquareComp"
objectUri="MagicSquareClass.remote" />
</service>
<lifetime leaseTime= "5M" renewOnCallTime="2M"
leaseManagerPollTime="10S" />
<channels>
<channel ref="tcp" port="1234">
<serverProviders>
<formatter ref="binary" typeFilterLevel="Full" />
</serverProviders>
</channel>
</channels>
</application>
<debug loadTypes="true"/>
</system.runtime.remoting>
</configuration>
This code specifies:
The mode in which the remote component will be accessed—in this case, single call mode
The name of the remote component, the component assembly, and the object URI (uniform resource identifier) used to access the remote component
The lease time for the remote component
The remoting protocol (TCP/IP) and port number
The message formatter (binary) and the permissions for the communication channel (full trust)
The server debugging option
The client application, running in a separate process, accesses the remote component running in the server application you built previously. (See Coding and Building the Hosting Server Application and Configuration File.
Next build the remote client using the Microsoft Visual Studio project file MagicSquareClient\MagicSquareMWClient.csproj. This file references both the shared data conversion assembly matlabroot\toolbox\dotnetbuilder\bin\win32\v2.0\ MWArray.dll and the generated component interface assembly MagicSquareComp\distrib\IMagicSquareComp.
To create the remote client using Microsoft Visual Studio:
Select the appropriate build platform.
Select Debug or Release mode.
Build the MagicSquareMWClient project.
Supply the configuration file for the MagicSquareMWServer.
MagicSquareClient Code. Use the C# code for the client located in the file MagicSquareClient\MagicSquareClient.cs. The client code is shown here:
using System;
using System.Configuration;
using System.Runtime.Remoting;
using System.Runtime.Remoting.Channels;
using System.Runtime.Remoting.Channels.Http;
using System.Collections;
using System.Runtime.Serialization.Formatters;
using System.Runtime.Remoting.Channels.Tcp;
using MathWorks.MATLAB.NET.Utility;
using MathWorks.MATLAB.NET.Arrays;
using IMagicSquareComp;
namespace MagicSquareClient
{
class MagicSquareClient
{
static void Main(string[] args)
{
try
{
RemotingConfiguration.Configure
(@"MagicSquareClient.exe.config");
String urlServer=
ConfigurationSettings.AppSettings["MagicSquareServer"];
IMagicSquareClass magicSquareComp=
(IMagicSquareClass)Activator.GetObject
(typeof(IMagicSquareClass),
urlServer);
// Get user specified command line arguments or set default
double arraySize= (0 != args.Length)
? Double.Parse(args[0]) : 4;
// Compute the magic square and print the result
MWNumericArray magicSquare=
(MWNumericArray)magicSquareComp.makesquare
(arraySize);
Console.WriteLine("Magic square of order {0}\n\n{1}",
arraySize, magicSquare);
}
catch (Exception exception)
{
Console.WriteLine(exception.Message);
}
Console.ReadLine();
}
}
}
This code does the following:
The client reads the associated configuration file to get the name and location of the remoteable component.
The client instantiates the remoteable object using the static Activator.GetObject method
From this point, the remoting client calls methods on the remoteable component exactly as it would call a local component method.
MagicSquareClient Configuration File. The configuration file for the magic square client is in the file MagicSquareClient\MagicSquareClient.exe.config. The configuration file, written in XML, is shown here:
<?xml version="1.0" encoding="utf-8" ?>
<configuration>
<appSettings>
<add key="MagicSquareServer"
value="tcp://localhost:1234/MagicSquareClass.remote"/>
</appSettings>
<system.runtime.remoting>
<application>
<channels>
<channel name="MagicSquareChannel" ref="tcp" port="0">
<clientProviders>
<formatter ref="binary" />
</clientProviders>
<serverProviders>
<formatter ref="binary" typeFilterLevel="Full" />
</serverProviders>
</channel>
</channels>
</application>
</system.runtime.remoting>
</configuration>
This code specifies:
The name of the remote component server and the remote component URI (uniform resource identifier)
The remoting protocol (TCP/IP) and port number
The message formatter (binary) and the permissions for the communication channel (full trust)
Starting the server by doing the following:
Open a DOS or UNIX® command window and cd to MagicSquareServer\bin\x86\v2.0\Debug.
Run MagicSquareServer.exe. You will see the message:
Magic Square Server started...
Start the client by doing the following:
Open a DOS or UNIX command window and cd to MagicSquareClient\bin\x86\v2.0\Debug.
Run MagicSquareClient.exe. After the MCR initializes, you should see the following output:
Magic square of order 4 16 2 3 13 5 11 10 8 9 7 6 12 4 14 15 1
.NET Developer
| Role | Knowledge Base | Responsibilities |
|---|---|---|
|
.NET
Developer |
|
|
After the remotable component has been created, you can set up a server application and client using the native .NET API. For more information on choosing the right API for your access needs, see Selecting the Best Method of Accessing Your Component: MWArray API or Native .NET API.
Some reasons you might use the native .NET API instead of the MWArray API are:
You want to pass arguments and return values using standard .NET types, and you or your users don't work extensively with data types specific to MATLAB.
You want to access your component from a client machine without an installed version of MATLAB.
For information on accessing your component using the MWArray API, see Using the MWArray API.
The server application will host the remote component you built in Creating a Remotable .NET Component.
The client application, running in a separate process, will access the remote component hosted by the server application. Build the server with the Microsoft Visual Studio project file MagicSquareServer\MagicSquareMWServer.csproj:
Change the references for the generated component assembly to MagicSquareComp\distrib\MagicSquareCompNative.dll.
Select the appropriate build platform (32-bit or 64-bit).
Select Debug or Release mode.
Build the MagicSquareServer project.
Supply the configuration file for the MagicSquareServer.
MagicSquareServer Code. The C# code for the server is in the file MagicSquareServer\MagicSquareServer.cs. The MagicSquareServer.cs server code is shown here:
using System;
using System.Runtime.Remoting;
namespace MagicSquareServer
{
class MagicSquareServer
{
static void Main(string[] args)
{
RemotingConfiguration.Configure
(@"..\..\..\..\MagicSquareServer.exe.config");
Console.WriteLine("Magic Square Server started...");
Console.ReadLine();
}
}
}
This code does the following:
Reads the associated configuration file to determine the name of the component that it will host, the remoting protocol and message formatting to use, as well as the lease time for the remote component.
Signals that the server is active and waits for a carriage return to be entered before terminating.
MagicSquareServer Configuration File. The configuration file for the MagicSquareServer is in the file MagicSquareServer\MagicSquareServer.exe.config. The entire configuration file, written in XML, is shown here:
<?xml version="1.0" encoding="utf-8" ?>
<configuration>
<system.runtime.remoting>
<application>
<service>
<wellknown mode="SingleCall"
type="MagicSquareCompNative.MagicSquareClass,
MagicSquareCompNative"
objectUri="MagicSquareClass.remote" />
</service>
<lifetime leaseTime= "5M" renewOnCallTime="2M"
leaseManagerPollTime="10S" />
<channels>
<channel ref="tcp" port="1234">
<serverProviders>
<formatter ref="binary" typeFilterLevel="Full" />
</serverProviders>
</channel>
</channels>
</application>
<debug loadTypes="true"/>
</system.runtime.remoting>
</configuration>
This code specifies:
The mode in which the remote component will be accessed—in this case, single call mode
The name of the remote component, the component assembly, and the object URI (uniform resource identifier) used to access the remote component
The lease time for the remote component
The remoting protocol (TCP/IP) and port number
The message formatter (binary) and the permissions for the communication channel (full trust)
The server debugging option
The client application, running in a separate process, accesses the remote component running in the server application built in Coding and Building the Hosting Server Application and Configuration File. Build the remote client using the Microsoft Visual Studio project file MagicSquareClient\MagicSquareClient.csproj which references both the shared data conversion assembly matlabroot\toolbox\dotnetbuilder\bin\win32\v2.0\ MWArray.dll and the generated component interface assembly MagicSquareComp\distrib\IMagicSquareCompNative. To create the remote client using Microsoft Visual Studio:
Select the appropriate build platform.
Select Debug or Release mode.
Build the MagicSquareClient project.
Supply the configuration file for the MagicSquareServer.
MagicSquareClient Code. The C# code for the client is in the file MagicSquareClient\MagicSquareClient.cs. The client code is shown here:
using System;
using System.Configuration;
using System.Runtime.Remoting;
using System.Runtime.Remoting.Channels;
using System.Runtime.Remoting.Channels.Http;
using System.Collections;
using System.Runtime.Serialization.Formatters;
using System.Runtime.Remoting.Channels.Tcp;
using IMagicSquareCompNative;
namespace MagicSquareClient
{
class MagicSquareClient
{
static void Main(string[] args)
{
try
{
RemotingConfiguration.Configure
(@"MagicSquareClient.exe.config");
String urlServer=
ConfigurationSettings.AppSettings["MagicSquareServer"];
IMagicSquareClassNative magicSquareComp=
(IMagicSquareClassNative)Activator.GetObject
(typeof(IMagicSquareClassNative), urlServer);
// Get user specified command line arguments or set default
double arraySize= (0 != args.Length)
? Double.Parse(args[0]) : 4;
// Compute the magic square and print the result
double[,] magicSquare=
(double[,])magicSquareComp.makesquare(arraySize);
Console.WriteLine("Magic square of order {0}\n", arraySize);
// Display the array elements:
for (int i = 0; i < (int)arraySize; i++)
for (int j = 0; j < (int)arraySize; j++)
Console.WriteLine
("Element({0},{1})= {2}", i, j, magicSquare[i, j]);
}
catch (Exception exception)
{
Console.WriteLine(exception.Message);
}
Console.ReadLine();
}
}
}
This code does the following:
The client reads the associated configuration file to get the name and location of the remoteable component.
The client instantiates the remoteable object using the static Activator.GetObject method
From this point, the remoting client calls methods on the remoteable component exactly as it would call a local component method.
MagicSquareClient Configuration File. The configuration file for the magic square client is in the file MagicSquareClient\MagicSquareClient.exe.config. The configuration file, written in XML, is shown here:
<?xml version="1.0" encoding="utf-8" ?>
<configuration>
<appSettings>
<add key="MagicSquareServer"
value="tcp://localhost:1234/MagicSquareClass.remote"/>
</appSettings>
<system.runtime.remoting>
<application>
<channels>
<channel name="MagicSquareChannel" ref="tcp" port="0">
<clientProviders>
<formatter ref="binary" />
</clientProviders>
<serverProviders>
<formatter ref="binary" typeFilterLevel="Full" />
</serverProviders>
</channel>
</channels>
</application>
</system.runtime.remoting>
</configuration>
This code specifies:
The name of the remote component server and the remote component URI (uniform resource identifier)
The remoting protocol (TCP/IP) and port number
The message formatter (binary) and the permissions for the communication channel (full trust)
Start the server by doing the following:
Open a DOS or UNIX command and cd to MagicSquareServer\bin\x86\v2.0\Debug.
Run MagicSquareServer.exe. You will see the message:
Magic Square Server started...
Start the client by doing the following:
Open a DOS or UNIX command window and cdto MagicSquareClient\bin\x86\v2.0\Debug.
Run MagicSquareClient.exe. After the MCR initializes you should see the following output:
Magic square of order 4 Element(0,0)= 16 Element(0,1)= 2 Element(0,2)= 3 Element(0,3)= 13 Element(1,0)= 5 Element(1,1)= 11 Element(1,2)= 10 Element(1,3)= 8 Element(2,0)= 9 Element(2,1)= 7 Element(2,2)= 6 Element(2,3)= 12 Element(3,0)= 4 Element(3,1)= 14 Element(3,2)= 15 Element(3,3)= 1
Using .NET representations of MATLAB struct and cell arrays is recommended if both of these are true:
You have MATLAB functions on a server with MATLAB struct or cell data types as inputs or outputs
You do not want or need to install an MCR on your client machines
The native MWArray, MWStructArray, and MWCellArray classes are members of the MathWorks.MATLAB.NET.Arrays.native namespace.
The class names in this namespace are identical to the class names in the MathWorks.MATLAB.NET.Arrays. The difference is that the native representation of struct and cell arrays have no methods or properties that require an MCR.
The matlabroot\toolbox\dotnetbuilder\Examples\VS8\NET folder has example solutions you can practice building. The NativeStructCellExample folder contains native struct and cell examples.
This example demonstrates how to deploy a remotable component using native struct and cell arrays. Before you set up the remotable client and server code, build a remotable component.
If you have not yet built the component you want to deploy, see the instructions in Building a Remotable Component Using the Deployment Tool or Building a Remotable Component Using the mcc Command.
The server application hosts the remote component.
The client application, running in a separate process, accesses the remote component hosted by the server application. Build the server with the Microsoft Visual Studio project file NativeStructCellServer.csproj:
Change the references for the generated component assembly to component_name\distrib\component_nameNative.dll.
Select the appropriate build platform.
Select Debug or Release mode.
Build the NativeStructCellServer project.
Supply the configuration file for the NativeStructCellServer. The C# code for the server is in the file NativeStructCellServer.cs:
using System;
using System.Collections.Generic;
using System.Text;
using System.Runtime.Remoting;
namespace NativeStructCellServer
{
class NativeStructCellServer
{
static void Main(string[] args)
{
RemotingConfiguration.Configure(
@"NativeStructCellServer.exe.config");
Console.WriteLine("NativeStructCell Server started...");
Console.ReadLine();
}
}
}
This code reads the associated configuration file to determine:
Name of the component to host
Remoting protocol and message formatting to use
Lease time for the remote component
In addition, the code also signals that the server is active and waits for a carriage return before terminating.
The client application, running in a separate process, accesses the remote component running in the server application built in The Native .NET Cell and Struct Example. Build the remote client using the Microsoft Visual Studio project file NativeStructCellClient\NativeStructCellClient.csproj which references both the shared data conversion assembly matlabroot\toolbox\dotnetbuilder\bin\win32\v2.0\ MWArray.dll and the generated component interface assembly component_name\distrib\Icomponent_nameNative. To create the remote client using Microsoft Visual Studio:
Select the appropriate build platform.
Select Debug or Release mode.
Build the NativeStructCellClient project.
Supply the configuration file for the NativeStructCellClient.
NativeStructCellClient Code. The C# code for the client is in the file NativeStructCellClient\NativeStructCellClient.cs:
using System;
using System.Collections.Generic;
using System.Text;
using System.Runtime.Remoting;
using System.Configuration;
using MathWorks.MATLAB.NET.Arrays.native;
using INativeStructCellCompNative;
// This is a simple example that demonstrates the use
// of MathWorks.MATLAB.NET.Arrays.native package.
namespace NativeStructCellClient
{
class NativeStructCellClient
{
static void Main(string[] args)
{
try
{
RemotingConfiguration.Configure(
@"NativeStructCellClient.exe.config");
String urlServer =
ConfigurationSettings.AppSettings["NativeStructCellServer"];
INativeStructCellClassNative nativeStructCell =
(INativeStructCellClassNative)Activator.GetObject(typeof
(INativeStructCellClassNative), urlServer);
MWCellArray field_names = new MWCellArray(1, 2);
field_names[1, 1] = "Name";
field_names[1, 2] = "Address";
Object[] o = nativeStructCell.createEmptyStruct(1,field_names);
MWStructArray S1 = (MWStructArray)o[0];
Console.WriteLine("\nEVENT 2: Initialized structure as
received in client applications:\n\n{0}" , S1);
//Convert "Name" value from char[,] to a string since there's
no MWCharArray constructor on server that accepts
//char[,] as input.
char c = ((char[,])S1["Name"])[0, 0];
S1["Name"] = c.ToString();
MWStructArray address = new MWStructArray(new int[] { 1, 1 },
new String[] { "Street", "City", "State", "Zip" });
address["Street", 1] = "3, Apple Hill Drive";
address["City", 1] = "Natick";
address["State", 1] = "MA";
address["Zip", 1] = "01760";
Console.WriteLine("\nUpdating the 'Address' field to
:\n\n{0}", address);
Console.WriteLine("\n#################################\n");
S1["Address",1] = address;
Object[] o1 = nativeStructCell.updateField(1, S1, "Name");
MWStructArray S2 = (MWStructArray)o1[0];
Console.WriteLine("\nEVENT 5: Final structure as
received by client:\n\n{0}" , S2);
Console.WriteLine("\nAddress field: \n\n{0}" , S2["Address",1]);
Console.WriteLine("\n#################################\n");
}
catch (Exception exception)
{
Console.WriteLine(exception.Message);
}
Console.ReadLine();
}
}
}
This code does the following:
The client reads the associated configuration file to get the name and location of the remoteable component.
The client instantiates the remoteable object using the static Activator.GetObject method
From this point, the remoting client calls methods on the remoteable component exactly as it would call a local component method.
NativeStructCellClient Configuration File. The configuration file for the NativeStructCellClient is in the file NativeStructCellClient\NativeStructCellClient.exe.config:
<?xml version="1.0" encoding="utf-8" ?>
<configuration>
<appSettings>
<add key="NativeStructCellServer" value=
"tcp://localhost:1236/NativeStructCellClass.remote"/>
</appSettings>
<system.runtime.remoting>
<application>
<channels>
<channel name="NativeStructCellChannel" ref="tcp" port="0">
<clientProviders>
<formatter ref="binary" />
</clientProviders>
<serverProviders>
<formatter ref="binary" typeFilterLevel="Full" />
</serverProviders>
</channel>
</channels>
</application>
</system.runtime.remoting>
</configuration>
This code specifies:
Name of the remote component server and the remote component URI (uniform resource identifier)
Remoting protocol (TCP/IP) and port number
Message formatter (binary) and the permissions for the communication channel (full trust)
Start the server by doing the following:
Open a DOS or UNIX command window and cd to NativeStructCellServer\bin\x86\v2.0\Debug.
Run NativeStructCellServer.exe. The following output appears:
EVENT 1: Initializing the structure on server and sending
it to client:
Initialized empty structure:
Name: ' '
Address: []
##################################
EVENT 3: Partially initialized structure as
received by server:
Name: ' '
Address: [1x1 struct]
Address field as initialized from the client:
Street: '3, Apple Hill Drive'
City: 'Natick'
State: 'MA'
Zip: '01760'
##################################
EVENT 4: Updating 'Name' field before sending the
structure back to the client:
Name: 'The MathWorks'
Address: [1x1 struct]
##################################
Start the client by doing the following:
Open a DOS or UNIX command window and cd to NativeStructCellClient\bin\x86\v2.0\Debug.
Run NativeStructCellClient.exe. After the MCR initializes, the following output appears:
EVENT 2: Initialized structure as
received in client applications:
1x1 struct array with fields:
Name
Address
Updating the 'Address' field to :
1x1 struct array with fields:
Street
City
State
Zip
#################################
EVENT 5: Final structure as received by client:
1x1 struct array with fields:
Name
Address
Address field:
1x1 struct array with fields:
Street
City
State
Zip
#################################
createEmptyStruct.m. Initialize the structure on the server and send it to the client with the following MATLAB code:
function PartialStruct = createEmptyStruct(field_names)
fprintf('EVENT 1: Initializing the structure on server
and sending it to client:\n');
PartialStruct = struct(field_names{1},' ',field_names{2},[]);
fprintf(' Initialized empty structure:\n\n');
disp(PartialStruct);
fprintf('\n##################################\n');
updateField.m. Receive the partially updated structure from the client and add more data to it, before passing it back to the client, with the following MATLAB code:
function FinalStruct = updateField(st,field_name)
fprintf('\nEVENT 3: Partially initialized structure as
received by server:\n\n');
disp(st);
fprintf('Address field as initialized from the client:\n\n');
disp(st.Address);
fprintf('##################################\n');
fprintf(['\nEVENT 4: Updating ''', field_name, '''
field before sending the structure back to the client:\n\n']);
st.(field_name) = 'The MathWorks';
FinalStruct = st;
disp(FinalStruct);
fprintf('\n##################################\n');
NativeStructCellClient.cs. Create the client C# code:
using System;
using System.Collections.Generic;
using System.Text;
using System.Runtime.Remoting;
using System.Configuration;
using MathWorks.MATLAB.NET.Arrays.native;
using INativeStructCellCompNative;
// This is a simple example that demonstrates the use of
// MathWorks.MATLAB.NET.Arrays.native package.
namespace NativeStructCellClient
{
class NativeStructCellClient
{
static void Main(string[] args)
{
try
{
RemotingConfiguration.Configure
(@"NativeStructCellClient.exe.config");
String urlServer =
ConfigurationSettings.AppSettings[
"NativeStructCellServer"];
INativeStructCellClassNative nativeStructCell =
(INativeStructCellClassNative)Activator.GetObject(typeof
(INativeStructCellClassNative),
urlServer);
MWCellArray field_names = new MWCellArray(1, 2);
field_names[1, 1] = "Name";
field_names[1, 2] = "Address";
Object[] o = nativeStructCell.createEmptyStruct(1,field_names);
MWStructArray S1 = (MWStructArray)o[0];
Console.WriteLine("\nEVENT 2: Initialized structure as received
in client applications:\n\n{0}" , S1);
//Convert "Name" value from char[,] to a string since
// there's no MWCharArray constructor
// on server that accepts char[,] as input.
char c = ((char[,])S1["Name"])[0, 0];
S1["Name"] = c.ToString();
MWStructArray address =
want new MWStructArray(new int[] { 1, 1 },
new String[] { "Street", "City", "State", "Zip" });
address["Street", 1] = "3, Apple Hill Drive";
address["City", 1] = "Natick";
address["State", 1] = "MA";
address["Zip", 1] = "01760";
Console.WriteLine("\nUpdating the
'Address' field to :\n\n{0}", address);
Console.WriteLine("\n#################################\n");
S1["Address",1] = address;
Object[] o1 = nativeStructCell.updateField(1, S1, "Name");
MWStructArray S2 = (MWStructArray)o1[0];
Console.WriteLine("\nEVENT 5: Final structure as received by
client:\n\n{0}" , S2);
Console.WriteLine("\nAddress field: \n\n{0}" , S2["Address",1]);
Console.WriteLine("\n#################################\n");
}
catch (Exception exception)
{
Console.WriteLine(exception.Message);
}
Console.ReadLine();
}
}
}
NativeStructCellServer.cs. Create the server C# code:
using System;
using System.Collections.Generic;
using System.Text;
using System.Runtime.Remoting;
namespace NativeStructCellServer
{
class NativeStructCellServer
{
static void Main(string[] args)
{
RemotingConfiguration.Configure(
@"NativeStructCellServer.exe.config");
Console.WriteLine("NativeStructCell Server started...");
Console.ReadLine();
}
}
}
 | Creating a Remotable .NET Component | Troubleshooting |  |
Includes the most popular MATLAB recorded presentations with Q&A sessions led by MATLAB experts.
| © 1984-2012- The MathWorks, Inc. - Site Help - Patents - Trademarks - Privacy Policy - Preventing Piracy - RSS |
