Public Function TaskCreateWriter ( _
	samplesInBuffer As Integer, _
	analogChannels As Integer(), _
	pwmChannels As Integer(), _
	digitalChannels As Integer(), _
	otherChannels As Integer() _
) As Hil..::.Task

public Hil..::.Task TaskCreateWriter(
	int samplesInBuffer,
	int[] analogChannels,
	int[] pwmChannels,
	int[] digitalChannels,
	int[] otherChannels
)

public:
Hil..::.Task^ TaskCreateWriter(
	int samplesInBuffer, 
	array<int>^ analogChannels, 
	array<int>^ pwmChannels, 
	array<int>^ digitalChannels, 
	array<int>^ otherChannels
)

function taskCreateWriter(samplesInBuffer, analogChannels, pwmChannels, digitalChannels, otherChannels);

int [] analogChannels  = { 0, 1, 2, 3 };
int [] pwmChannels     = { 0, 1 };
double frequency       = 1000;
int    samples         = 5000;
int    samplesInBuffer = frequency;
int    samplesToWrite  = 100;

double [] analogBuffer = new double [samplesToWrite * analogChannels.Length];
double [] pwmBuffer    = new double [samplesToWrite * pwmChannels.Length];
Hil.Task task;

/* ... fill buffers with samplesToWrite samples ... */

/* Create task */
task = card.TaskCreateWriter(samplesInBuffer, analogChannels, pwmChannels, nullptr, nullptr);

/* Preload task buffer with first samplesToWrite samples prior to starting task */
task.Write(samplesToWrite, analogBuffer, pwmBuffer, nullptr, nullptr);

/* Start task */
task.Start(Hil.Clock.Hardware0, frequency, samples);
for (int index = samples; index < samples; index += samples_to_write) {
    /* ... fill buffers with next samplesToWrite samples ... */

    /*
        Block (if necessary) waiting to write next samplesToWrite samples.
        However, it only waits for space in the task buffer (which can contain
        samplesInBuffer samples), not for the data to actually be written to
        the hardware. Hence, it will not block until the task buffer is full
        (a little over one second in this example since samplesInBuffer is 1000).
    */
    task.Write(samplesToWrite, analogBuffer, pwmBuffer, nullptr, nullptr);
}

/* Flush to make sure all data has been written to the hardware before stopping task */
task.Flush();
task.Stop();

Dim analogChannels() As Integer = {0, 1, 2, 3}
Dim pwmChannels() As Integer = {0, 1}
Dim frequency as Double = 1000
Dim samples As Integer = 5000
Dim samplesInBuffer As Integer = frequency
Dim samplesToWrite As Integer = 100

Dim analogBuffer(samplesToWrite * analogChannels.Length - 1) As Double
Dim pwmBuffer(samplesToWrite * pwmChannels.Length - 1) As Double
Dim task As Hil.Task
Dim index As Integer

' ... fill buffers with samplesToWrite samples ...

' Create task
task = card.TaskCreateWriter(samplesInBuffer, analogChannels, pwmChannels, Hil.NoChannels, Hil.NoChannels)

' Preload task buffer with first samplesToWrite samples prior to starting task
task.Write(samplesToWrite, analogBuffer, pwmBuffer, Hil.NoBooleanBuffer, Hil.NoDoubleBuffer)

' Start task
task.Start(Hil.Clock.Hardware0, frequency, samples)
For index = 0 To samples - 1 Step samplesToWrite
    ' ... fill buffers with next samplesToWrite sample ...

    ' Block (if necessary) waiting to write next samplesToWrite samples.
    ' However, it only waits for space in the task buffer (which can contain
    ' samplesInBuffer samples), not for the data to actually be written to
    ' the hardware. Hence, it will not block until the task buffer is full
    ' (a little over one second in this example since samplesInBuffer is 1000).
    task.Write(samplesToWrite, analogBuffer, pwmBuffer, Hil.NoBooleanBuffer, Hil.NoDoubleBuffer)
Next

' Flush to make sure all data has been written to the hardware before stopping task
task.Flush()
task.Stop()

array<int>^ analogChannels  = { 0, 1, 2, 3 };
array<int>^ pwmChannels     = { 0, 1 };
double      frequency       = 1000;
int         samples         = 5000;
int         samplesInBuffer = frequency;
int         samplesToWrite  = 100;

array<double>^ analogBuffer = gcnew array<double>(samplesToWrite * analogChannels->Length);
array<double>^ pwmBuffer    = gcnew array<double>(samplesToWrite * pwmChannels->Length);
Hil::Task^ task;

/* ... fill buffers with samplesToWrite samples ... */

/* Create task */
task = card->TaskCreateWriter(samplesInBuffer, analogChannels, pwmChannels, nullptr, nullptr);

/* Preload task buffer with first samplesToWrite samples prior to starting task */
task->Write(samplesToWrite, analogBuffer, pwmBuffer, nullptr, nullptr);

/* Start task */
task->Start(Hil::Clock::Hardware0, frequency, samples);
for (int index = 0; index < samples; index += samplesToWrite) {
    /* ... fill buffers with next samplesToWrite samples ... */

    /*
        Block (if necessary) waiting to write next samplesToWrite samples.
        However, it only waits for space in the task buffer (which can contain
        samplesInBuffer samples), not for the data to actually be written to
        the hardware. Hence, it will not block until the task buffer is full
        (a little over one second in this example since samplesInBuffer is 1000).
    */
    task->Write(samplesToWrite, analogBuffer, pwmBuffer, nullptr, nullptr);
}

/* Flush to make sure all data has been written to the hardware before stopping task */
task->Flush();
task->Stop();