Batch assignments let you read a group of registers, variables, or signals in a single SNPX command instead of individual requests. This dramatically improves throughput for high-frequency data exchange.

## How it works

1. **Create** a batch assignment specifying the data range or variable names
2. **Read** the entire batch in a single call
3. **Repeat** the read call as often as needed : the assignment is reusable

The amount of data in a single command has no significant impact on execution time. Reading 80 position registers in batch takes the same ~2 ms as reading a single register.

## Batch reading

**C# : SnpxBatchRegisters**
```csharp
using UnderAutomation.Fanuc;
using UnderAutomation.Fanuc.Common;

public class SnpxBatchRegisters
{
    static void Main()
    {
        FanucRobot robot = new FanucRobot();
        var parameters = new ConnectionParameters("192.168.0.1");
        parameters.Snpx.Enable = true;
        robot.Connect(parameters);

        /**/
        // Numeric registers batch: read R[1] through R[100]
        var numBatch = robot.Snpx.NumericRegisters.CreateBatchAssignment(1, 100);
        float[] values = numBatch.Read();

        // Position registers batch: read PR[1] through PR[50]
        var posBatch = robot.Snpx.PositionRegisters.CreateBatchAssignment(1, 50);
        Position[] positions = posBatch.Read();

        // String registers batch
        var strBatch = robot.Snpx.StringRegisters.CreateBatchAssignment(1, 20);
        string[] strings = strBatch.Read();

        // Flag registers batch
        var flagBatch = robot.Snpx.Flags.CreateBatchAssignment(1, 100);
        bool[] flags = flagBatch.Read();

        // System variables batch
        var intBatch = robot.Snpx.IntegerSystemVariables.CreateBatchAssignment(
            new[] { "$RMT_MASTER", "$MCR.$GENOVERRIDE", "$SCR.$NUM_GROUP" });
        int[] intValues = intBatch.Read();
        /**/
    }
}
```

**Python : SnpxBatchRegisters**
```python
from underautomation.fanuc.fanuc_robot import FanucRobot
from underautomation.fanuc.connection_parameters import ConnectionParameters

robot = FanucRobot()
parameters = ConnectionParameters("192.168.0.1")
parameters.snpx.enable = True
robot.connect(parameters)

##
# Numeric registers batch: read R[1] through R[100]
num_batch = robot.snpx.numeric_registers.create_batch_assignment(1, 100)
values = num_batch.read()

# Position registers batch: read PR[1] through PR[50]
pos_batch = robot.snpx.position_registers.create_batch_assignment(1, 50)
positions = pos_batch.read()

# String registers batch
str_batch = robot.snpx.string_registers.create_batch_assignment(1, 20)
strings = str_batch.read()

# Flag registers batch
flag_batch = robot.snpx.flags.create_batch_assignment(1, 100)
flags = flag_batch.read()

# System variables batch
int_batch = robot.snpx.integer_system_variables.create_batch_assignment(
    ["$RMT_MASTER", "$MCR.$GENOVERRIDE", "$SCR.$NUM_GROUP"])
int_values = int_batch.read()
##
```

## Performance comparison

| Method | 80 position registers | Time |
|--------|----------------------|------|
| Individual reads | 80 × `PositionRegisters.Read()` | ~160 ms |
| Batch read | 1 × `BatchAssignment.Read()` | ~2 ms |

Batch reading is **80x faster** for this example.

## Complete example

**C# : SnpxBatch**
```csharp
using UnderAutomation.Fanuc;
using UnderAutomation.Fanuc.Common;
using UnderAutomation.Fanuc.Snpx.Assignment;

public class SnpxBatch
{
  public static void Main()
  {
    FanucRobot robot = new FanucRobot();

    ConnectionParameters parameters = new ConnectionParameters("192.168.0.1");
    parameters.Snpx.Enable = true;

    robot.Connect(parameters);

    /**/
    // --- Numeric registers batch ---
    var numBatch = robot.Snpx.NumericRegisters.CreateBatchAssignment(1, 100);
    float[] numValues = numBatch.Read();

    // --- Position registers batch ---
    var posBatch = robot.Snpx.PositionRegisters.CreateBatchAssignment(1, 50);
    Position[] positions = posBatch.Read();

    // --- String registers batch ---
    var strBatch = robot.Snpx.StringRegisters.CreateBatchAssignment(1, 20);
    string[] strings = strBatch.Read();

    // --- Flag registers batch ---
    var flagBatch = robot.Snpx.Flags.CreateBatchAssignment(1, 100);
    bool[] flags = flagBatch.Read();

    // --- Integer system variables batch ---
    var intBatch = robot.Snpx.IntegerSystemVariables.CreateBatchAssignment(
        new[] { "$RMT_MASTER", "$MCR.$GENOVERRIDE", "$SCR.$NUM_GROUP" });
    int[] intValues = intBatch.Read();

    // --- Digital signals batch ---
    bool[] sdiValues = robot.Snpx.SDI.Read(1, 200);

    // --- Numeric I/O batch ---
    ushort[] giValues = robot.Snpx.GI.Read(1, 50);

    // --- Re-read the same batch (reusable) ---
    float[] numValues2 = numBatch.Read();
    /**/
  }
}
```

**Python : SnpxBatch**
```python
from underautomation.fanuc.fanuc_robot import FanucRobot
from underautomation.fanuc.connection_parameters import ConnectionParameters

# Create a robot instance
robot = FanucRobot()

# Configure connection parameters
parameters = ConnectionParameters("192.168.0.1")
parameters.snpx.enable = True

# Connect to the robot
robot.connect(parameters)

##
# --- Numeric registers batch ---
num_batch = robot.snpx.numeric_registers.create_batch_assignment(1, 100)
num_values = num_batch.read()

# --- Position registers batch ---
pos_batch = robot.snpx.position_registers.create_batch_assignment(1, 50)
positions = pos_batch.read()

# --- String registers batch ---
str_batch = robot.snpx.string_registers.create_batch_assignment(1, 20)
strings = str_batch.read()

# --- Flag registers batch ---
flag_batch = robot.snpx.flags.create_batch_assignment(1, 100)
flags = flag_batch.read()

# --- Integer system variables batch ---
int_batch = robot.snpx.integer_system_variables.create_batch_assignment(
    ["$RMT_MASTER", "$MCR.$GENOVERRIDE", "$SCR.$NUM_GROUP"])
int_values = int_batch.read()

# --- Digital signals batch ---
sdi_batch = robot.snpx.sdi.create_batch_assignment(1, 200)
sdi_values = sdi_batch.read()

# --- Numeric I/O batch ---
gi_batch = robot.snpx.gi.create_batch_assignment(1, 50)
gi_values = gi_batch.read()

# --- Re-read the same batch (reusable) ---
num_values2 = num_batch.read()
##
```

## API reference

**Members of Snpx.Assignment.NumericRegistersBatchAssignment**
```csharp
public class NumericRegistersBatchAssignment : BatchAssignment<float, int> {
    // Initializes a new instance of the <xref href="UnderAutomation.Fanuc.Snpx.Assignment.NumericRegistersBatchAssignment" data-throw-if-not-resolved="false"></xref> class.
    public NumericRegistersBatchAssignment()

    // Read all numeric registers assigned in this batch assignment.
    public override float[] Read()
}
```

**Members of Snpx.Assignment.PositionRegistersBatchAssignment**
```csharp
public class PositionRegistersBatchAssignment : BatchAssignment<Position, int> {
    // Initializes a new instance of the <xref href="UnderAutomation.Fanuc.Snpx.Assignment.PositionRegistersBatchAssignment" data-throw-if-not-resolved="false"></xref> class.
    public PositionRegistersBatchAssignment()

    // Reads all position registers assigned in this batch.
    public override Position[] Read()
}
```