Link-OS Printer Tools and Multiplatform SDK

https://techdocs.zebra.com/link-os/3-00
Admin
The Link-OS Multiplatform Software Development Kit enables the creation of printing applications on...
Tokens:144,538
Snippets:1,250
Trust Score:10
Update:2 months ago
Show doc for...
Tokens:
Raw
### Update Printer Firmware Example

Source: https://techdocs.zebra.com/link-os/3-00/pc_net/content/html/4a5accb6-4920-9ec4-cb93-a3fff739e45e

Example demonstrating how to connect to a printer and initiate a firmware update using the UpdateFirmware method.

```C#
using System;
using Zebra.Sdk.Comm;
using Zebra.Sdk.Printer;

public class UpdatePrinterFirmwareExample {

    public static void Main(string[] args) {
        string theIpAddress = "1.2.3.4";

        // File path, e.g. "D:\\ZV68_19_6Z.zpl"
        string firmwareFilePath = "fullPathToFirmwareFile";

        Connection connection = new TcpConnection(theIpAddress, TcpConnection.DEFAULT_ZPL_TCP_PORT);
        try {
            connection.Open();
            ZebraPrinterLinkOs p = ZebraPrinterFactory.GetLinkOsPrinter(connection);

            // Send the firmware file to the printer.
            p.UpdateFirmware(firmwareFilePath, new UpdateFirmareHandler());
        } catch (Exception e) {
            Console.WriteLine(e.ToString());
        } finally {
            connection.Close();
        }
    }

    private class UpdateFirmareHandler : FirmwareUpdateHandler {

        public override void FirmwareDownloadComplete() {
            Console.WriteLine("Firmware download complete.");
        }

        public override void PrinterOnline(ZebraPrinterLinkOs printer, string firmwareVersion) {
            Console.WriteLine($"Printer online with firmware version={firmwareVersion}");
        }

        public override void ProgressUpdate(int bytesWritten, int totalBytes) {
        }
    }
}
```

--------------------------------

### Discover USB Printers Example

Source: https://techdocs.zebra.com/link-os/3-00/pc_net/content/html/9789c6ec-fe72-f455-0ac9-92d13311b70a

Example demonstrating how to enumerate Zebra Designer Drivers and connected USB printers using the UsbDiscoverer class.

```C#
using System;
using Zebra.Sdk.Comm;
using Zebra.Sdk.Printer.Discovery;

public class UsbDiscovererExample {

    public static void Main(string[] args) {
        try {
            foreach (DiscoveredPrinterDriver printer in UsbDiscoverer.GetZebraDriverPrinters()) {
                Console.WriteLine(printer);
            }

            foreach (DiscoveredUsbPrinter usbPrinter in UsbDiscoverer.GetZebraUsbPrinters(new ZebraPrinterFilter())) {
                Console.WriteLine(usbPrinter);
            }
        } catch (ConnectionException e) {
            Console.WriteLine($"Error discovering local printers: {e.Message}");
        }

        Console.WriteLine("Done discovering local printers.");
    }
}
```

--------------------------------

### SnmpPrinter Usage Example

Source: https://techdocs.zebra.com/link-os/3-00/pc_net/content/html/4d81b8b7-cdb0-67dc-4c1e-701d26496a5b

Example demonstrating how to instantiate an SnmpPrinter and perform SNMP get and set operations on printer OIDs.

```C#
using System;
using Zebra.Sdk.Printer;

public class SnmpPrinterExample {

    public static void Main(string[] args) {
        SnmpPrinter myPrinter = new SnmpPrinter("1.2.3.4", "getCommunityName", "setCommunityName");
        try {
            string printAdjOid = "1.3.6.1.4.1.10642.6.4.0";
            string printAdjFromSnmp = myPrinter.GetOidValue(printAdjOid);
            Console.WriteLine($"printAdj = {printAdjFromSnmp}");

            int newprintAdj = int.Parse(printAdjFromSnmp) + 1;
            myPrinter.SetOidValue(printAdjOid, newprintAdj);

            string friendlyNameOid = "1.3.6.1.4.1.10642.20.3.5.0";
            string friendlyNameFromSnmp = myPrinter.GetOidValue(friendlyNameOid);
            Console.WriteLine($"friendlyName = {friendlyNameFromSnmp}");

            string newfriendlyName = "AwesomePrinter";
            myPrinter.SetOidValue(friendlyNameOid, newfriendlyName);
        } catch (SnmpException e) {
            Console.WriteLine(e.ToString());
        }
    }
}
```

--------------------------------

### ZPL Format Example

Source: https://techdocs.zebra.com/link-os/3-00/pc_net/content/html/bcbef86f-bd08-475f-9a05-1ddb442ba403

Example of a ZPL format containing ^FN commands.

```text
^XA
            ^DFR:SHELF.ZPL^FS
            ^FO25,25^A0N,50,50^FN15"Name"^FS
            ^FO25,75^A0N,50,50^FN15"Address"^FS
            ^FO25,125^A0N,50,50^FN18^FS
            ^FO25,175^A0N,50,50^FN15
            ^XZ
```

--------------------------------

### FileUtil Usage Example

Source: https://techdocs.zebra.com/link-os/3-00/pc_net/content/html/8fad1fb4-d27a-3bee-8242-90f032b9145d

Demonstrates how to connect to a printer, send a file, and retrieve a list of files stored on the device.

```C#
using System;
using Zebra.Sdk.Comm;
using Zebra.Sdk.Device;
using Zebra.Sdk.Printer;

public class FileUtilExample {

    public static void Main(string[] args) {
        Connection connection = new TcpConnection("192.168.1.100", TcpConnection.DEFAULT_ZPL_TCP_PORT);

        try {
            connection.Open();
            ZebraPrinter printer = ZebraPrinterFactory.GetInstance(connection);
            printer.SendFileContents("C:\\Users\\[user]\\Documents\\labels\\sample.lbl");
            string[] fileNames = printer.RetrieveFileNames();
            foreach (string filename in fileNames) {
                Console.WriteLine(filename);
            }
        } catch (ConnectionException e) {
            Console.WriteLine(e.ToString());
        } catch (ZebraPrinterLanguageUnknownException e) {
            Console.WriteLine(e.ToString());
        } catch (ZebraIllegalArgumentException e) {
            Console.WriteLine(e.ToString());
        } finally {
            connection.Close();
        }
    }
}
```

--------------------------------

### SettingsSetter Usage Example

Source: https://techdocs.zebra.com/link-os/3-00/pc_net/content/html/370a5da9-9c15-f923-dd79-002109251944

Demonstrates how to use SettingsSetter.Process to retrieve and update printer settings via a dictionary.

```C#
using System;
using System.Collections.Generic;
using Zebra.Sdk.Comm;
using Zebra.Sdk.Printer;
using Zebra.Sdk.Settings;

public class SettingsSetterExample {

    public static void Main(string[] args) {
        string ipAddress = "192.168.1.100";

        Dictionary<string, string> settingsToSendToThePrinter = new Dictionary<string, string> {
            // Pass in a null as the second parameter to retrieve the setting
            { "device.friendly_name", null },

            // Pass in a value as the second parameter to set the setting
            { "comm.baud", "14400" }
        };

        // The map containing the results to each settings command
        Dictionary<string, string> results = null;

        try {
            results = SettingsSetter.Process(ipAddress, settingsToSendToThePrinter);
        } catch (ConnectionException e) {
            Console.WriteLine(e.ToString());
        } catch (SettingsException e) {
            Console.WriteLine(e.ToString());
        }

        foreach (KeyValuePair<string, string> entry in results) {
            Console.WriteLine($"The setting {entry.Key} returned {entry.Value}.");
        }
    }
}
```

--------------------------------

### Bluetooth Connection Example

Source: https://techdocs.zebra.com/link-os/3-00/pc_net/content/html/42dce628-947b-6386-e52d-77a93c3a203c

Demonstrates how to instantiate a BluetoothConnection, open the connection, and send ZPL or CPCL data to a printer.

```C#
using System;
using System.Text;
using Zebra.Sdk.Comm;

public class BluetoothConnectionExample {

    public static void Main(string[] Args) {
        BluetoothConnectionExample example = new BluetoothConnectionExample();

        string theBtMacAddress = "00:11:BB:DD:55:FF";
        example.SendZplOverBluetooth(theBtMacAddress);
        example.SendCpclOverBluetooth(theBtMacAddress);
    }

    private void SendZplOverBluetooth(string theBtMacAddress) {
        Connection thePrinterConn = null;
        try {
            // Instantiate connection for given Bluetooth® MAC Address.
            thePrinterConn = new BluetoothConnection(theBtMacAddress);

            // Open the connection - physical connection is established here.
            thePrinterConn.Open();

            // This example prints "This is a ZPL test." near the top of the label.
            string zplData = "^XA^FO20,20^A0N,25,25^FDThis is a ZPL test.^FS^XZ";

            // Send the data to printer as a byte array.
            thePrinterConn.Write(Encoding.UTF8.GetBytes(zplData));
        } catch (Exception e) {
            // Handle communications error here.
            Console.WriteLine(e.ToString());
        } finally {
            // Close the connection to release resources.
            if (thePrinterConn != null) {
                thePrinterConn.Close();
            }
        }
    }

    private void SendCpclOverBluetooth(string theBtMacAddress) {
        Connection thePrinterConn = null;
        try {
            // Instantiate connection for given Bluetooth® MAC Address.
            thePrinterConn = new BluetoothConnection(theBtMacAddress);

            // Open the connection - physical connection is established here.
            thePrinterConn.Open();

            // This example prints "This is a CPCL test." near the top of the label.
            string cpclData = "! 0 200 200 210 1\r\n"
                + "TEXT 4 0 30 40 This is a CPCL test.\r\n"
                + "FORM\r\n"
                + "PRINT\r\n";

            // Send the data to printer as a byte array.
            thePrinterConn.Write(Encoding.UTF8.GetBytes(cpclData));
        } catch (Exception e) {
            // Handle communications error here.
            Console.WriteLine(e.ToString());
        } finally {
            // Close the connection to release resources.
            if (thePrinterConn != null) {
                thePrinterConn.Close();
            }
        }
    }
}
```

--------------------------------

### Building a Connection from a String

Source: https://techdocs.zebra.com/link-os/3-00/pc_net/content/html/ba1a1ca6-598d-aaed-da69-e709a68b7eac

Example demonstrating how to use the ConnectionBuilder to establish various printer connections.

```C#
using System;
using System.Text;
using Zebra.Sdk.Comm;
using Zebra.Sdk.Printer;
using Zebra.Sdk.Printer.Discovery;

public class ConnectionBuilderExample {

    public static void Main(string[] args) {
        UsbDriverlessTest();

        new ConnectionBuilderExample().NonBlockingStatusReportingOverMultichannel("1.2.3.4");
        new ConnectionBuilderExample().SendZplOverTcp("1.2.3.4");
        new ConnectionBuilderExample().SendZplOverUsb("ZDesigner GK420t");
```

--------------------------------

### SettingsProvider Usage Example

Source: https://techdocs.zebra.com/link-os/3-00/pc_net/content/html/03d1eb1f-9a74-af9f-8e23-7c5cd484e7a5

Demonstrates how to discover a USB printer, retrieve available settings, display current values, and update a specific setting.

```C#
using System;
using System.Collections.Generic;
using Zebra.Sdk.Comm;
using Zebra.Sdk.Device;
using Zebra.Sdk.Printer;
using Zebra.Sdk.Printer.Discovery;
using Zebra.Sdk.Settings;

public class SettingsProviderExample {

    public static void Main(string[] args) {
        try {
            foreach (DiscoveredUsbPrinter usbPrinter in UsbDiscoverer.GetZebraUsbPrinters(new ZebraPrinterFilter())) {
                Connection c = usbPrinter.GetConnection();
                c.Open();
                if (c.Connected) {
                    DisplaySettings(c);
                }
                c.Close();
            }
        } catch (SettingsException e) {
            Console.WriteLine(e.ToString());
        } catch (ConnectionException e) {
            Console.WriteLine(e.ToString());
        } catch (ZebraPrinterLanguageUnknownException e) {
            Console.WriteLine(e.ToString());
        } catch (ZebraIllegalArgumentException e) {
            Console.WriteLine(e.ToString());
        }
    }

    private static void DisplaySettings(Connection c) {
        ZebraPrinter genericPrinter = ZebraPrinterFactory.GetInstance(c);
        ZebraPrinterLinkOs linkOsPrinter = ZebraPrinterFactory.CreateLinkOsPrinter(genericPrinter);

        if (linkOsPrinter != null) {
            Console.WriteLine("Available Settings for myDevice");
            HashSet<string> availableSettings = linkOsPrinter.GetAvailableSettings();
            foreach (string setting in availableSettings) {
                Console.WriteLine($"{setting}: Range = ({linkOsPrinter.GetSettingRange(setting)})");
            }

            Console.WriteLine("\nCurrent Setting Values for myDevice");
            Dictionary<string, string> allSettingValues = linkOsPrinter.GetAllSettingValues();
            foreach (string settingName in allSettingValues.Keys) {
                Console.WriteLine($"{settingName}:{allSettingValues[settingName]}");
            }

            string darknessSettingId = "print.tone";
            string newDarknessValue = "10.0";
            if (availableSettings.Contains(darknessSettingId) &&
                linkOsPrinter.IsSettingValid(darknessSettingId, newDarknessValue) &&
                linkOsPrinter.IsSettingReadOnly(darknessSettingId) == false) {
                linkOsPrinter.SetSetting(darknessSettingId, newDarknessValue);
            }

            Console.WriteLine($"\nNew {darknessSettingId} Value = {linkOsPrinter.GetSettingValue(darknessSettingId)}");
        }
    }
}
```

--------------------------------

### Multichannel Bluetooth Connection Example in C#

Source: https://techdocs.zebra.com/link-os/3-00/pc_net/content/html/010c1ed1-dfe9-b5c9-93f9-094236da3df6

Demonstrates how to instantiate a MultichannelBluetoothConnection, open the connection, and send ZPL or CPCL printer commands.

```C#
using System;
using System.Text;
using Zebra.Sdk.Comm;

public class BluetoothMultichannelConnectionExample {

    public static void Main(string[] Args) {
        BluetoothMultichannelConnectionExample example = new BluetoothMultichannelConnectionExample();

        string theBtMacAddress = "00:11:BB:DD:55:FF";
        example.SendZplOverBluetooth(theBtMacAddress);
        example.SendCpclOverBluetooth(theBtMacAddress);
    }

    private void SendZplOverBluetooth(string theBtMacAddress) {
        Connection thePrinterConn = null;
        try {
            // Instantiate connection for given Bluetooth® MAC Address.
            thePrinterConn = new MultichannelBluetoothConnection(theBtMacAddress);

            // Open the connection - physical connection is established here.
            thePrinterConn.Open();

            // This example prints "This is a ZPL test." near the top of the label.
            string zplData = "^XA^FO20,20^A0N,25,25^FDThis is a ZPL test.^FS^XZ";

            // Send the data to printer as a byte array.
            thePrinterConn.Write(Encoding.UTF8.GetBytes(zplData));
        } catch (Exception e) {
            // Handle communications error here.
            Console.WriteLine(e.ToString());
        } finally {
            // Close the connection to release resources.
            if (thePrinterConn != null) {
                thePrinterConn.Close();
            }
        }
    }

    private void SendCpclOverBluetooth(string theBtMacAddress) {
        Connection thePrinterConn = null;
        try {
            // Instantiate connection for given Bluetooth® MAC Address.
            thePrinterConn = new MultichannelBluetoothConnection(theBtMacAddress);

            // Open the connection - physical connection is established here.
            thePrinterConn.Open();

            // This example prints "This is a CPCL test." near the top of the label.
            string cpclData = "! 0 200 200 210 1\r\n"
                + "TEXT 4 0 30 40 This is a CPCL test.\r\n"
                + "FORM\r\n"
                + "PRINT\r\n";

            // Send the data to printer as a byte array.
            thePrinterConn.Write(Encoding.UTF8.GetBytes(cpclData));
        } catch (Exception e) {
            // Handle communications error here.
            Console.WriteLine(e.ToString());
        } finally {
            // Close the connection to release resources.
            if (thePrinterConn != null) {
                thePrinterConn.Close();
            }
        }
    }
}
```

--------------------------------

### ProfileUtil Usage Example

Source: https://techdocs.zebra.com/link-os/3-00/pc_net/content/html/1443363f-2b0b-63b7-bdff-a9c7e19f4490

Demonstrates how to use ProfileUtil to create, restore, or clone printer profiles via a TCP connection.

```C#
using System;
using System.IO;
using Zebra.Sdk.Comm;
using Zebra.Sdk.Device;
using Zebra.Sdk.Printer;

public class ProfileUtilExample {

    private enum ProfileOperations {
        CREATE_PROFILE, RESTORE_BACKUP, CLONE_A_PRINTER
    };

    public static void Main(string[] args) {
        string pathToProfile = "C:\\MyNewProfile.zprofile";
        ProfileOperations whatToDo = ProfileOperations.CREATE_PROFILE; // Change this to load the profile.
        TcpConnection connection = new TcpConnection("192.168.1.32", TcpConnection.DEFAULT_ZPL_TCP_PORT);
        try {
            connection.Open();

            ZebraPrinter genericPrinter = ZebraPrinterFactory.GetInstance(connection);
            ZebraPrinterLinkOs linkOsPrinter = ZebraPrinterFactory.CreateLinkOsPrinter(genericPrinter);

            if (linkOsPrinter != null) {
                Console.WriteLine("Start profile operation");
                switch (whatToDo) {
                    case ProfileOperations.CREATE_PROFILE:
                        linkOsPrinter.CreateProfile(pathToProfile);
                        break;

                    case ProfileOperations.RESTORE_BACKUP:
                        linkOsPrinter.LoadBackup(pathToProfile);
                        break;

                    case ProfileOperations.CLONE_A_PRINTER:
                        linkOsPrinter.LoadProfile(pathToProfile);
                        break;
                }
            }
        } catch (ConnectionException e) {
            Console.WriteLine("Could not use connection");
            Console.WriteLine(e.ToString());
        } catch (ZebraPrinterLanguageUnknownException e) {
            Console.WriteLine("Could not recognize Zebra printer");
            Console.WriteLine(e.ToString());
        } catch (ZebraIllegalArgumentException e) {
            Console.WriteLine("Unexpected response from Zebra printer");
            Console.WriteLine(e.ToString());
        } catch (IOException e) {
            Console.WriteLine("Could not write to " + pathToProfile);
            Console.WriteLine(e.ToString());
        } finally {
            connection.Close();
        }
    }
}
```

--------------------------------

### DiscoveryHandlerLinkOsOnly Usage Example

Source: https://techdocs.zebra.com/link-os/3-00/pc_net/content/html/abc0fddd-9135-1d65-73d6-f9bea2d8c5a8

Demonstrates how to implement and use the DiscoveryHandlerLinkOsOnly to discover Link-OS printers on a network.

```C#
using System;
using System.Collections.Generic;
using Zebra.Sdk.Printer.Discovery;

public class DiscoveryHandlerLinkOsOnlyExample {

    public static void Main(string[] args) {
        try {
            Console.WriteLine("Starting Link-OS(TM) printer discovery.");

            LinkOsDiscoveryHandler discoHandler = new LinkOsDiscoveryHandler();
            NetworkDiscoverer.FindPrinters(new DiscoveryHandlerLinkOsOnly(discoHandler));
            while (!discoHandler.DiscoveryComplete) {
                System.Threading.Thread.Sleep(10);
            }
        } catch (DiscoveryException e) {
            Console.WriteLine(e.ToString());
        }
    }

    private class LinkOsDiscoveryHandler : DiscoveryHandler {

        private bool discoveryComplete = false;
        List<DiscoveredPrinter> printers = new List<DiscoveredPrinter>();

        public void DiscoveryError(string message) {
            Console.WriteLine($"An error occurred during discovery: {message}.");
            discoveryComplete = true;
        }

        public void DiscoveryFinished() {
            foreach (DiscoveredPrinter printer in printers) {
                Console.WriteLine(printer);
            }
            Console.WriteLine($"Discovered {printers.Count} Link-OS(TM) printers.");
            discoveryComplete = true;
        }

        public void FoundPrinter(DiscoveredPrinter printer) {
            printers.Add(printer);
        }

        public bool DiscoveryComplete {
            get => discoveryComplete;
        }
    }
}
```

--------------------------------

### Bluetooth Printer Discovery Example

Source: https://techdocs.zebra.com/link-os/3-00/pc_net/content/html/920db44d-4f25-6fe0-1c58-efecabc7e3cc

Demonstrates how to use the BluetoothDiscoverer to find printers and handle discovery events using a custom handler.

```C#
using System;
using System.Collections.Generic;
using Zebra.Sdk.Printer.Discovery;

class BluetoothDiscovererExample {

    public static void Main(string[] args) {
        try {
            Console.WriteLine("Starting printer discovery.");

            BluetoothDiscoveryHandler discoveryHandler = new BluetoothDiscoveryHandler();
            BluetoothDiscoverer.FindPrinters(discoveryHandler);
            while (!discoveryHandler.DiscoveryComplete) {
                System.Threading.Thread.Sleep(10);
            }
        } catch (DiscoveryException e) {
            Console.WriteLine(e.ToString());
        }
    }

    private class BluetoothDiscoveryHandler : DiscoveryHandler {

        private bool discoveryComplete = false;
        List<DiscoveredPrinter> printers = new List<DiscoveredPrinter>();

        public void DiscoveryError(string message) {
            Console.WriteLine($"An error occurred during discovery: {message}.");
            discoveryComplete = true;
        }

        public void DiscoveryFinished() {
            foreach (DiscoveredPrinter printer in printers) {
                Console.WriteLine(printer);
            }
            Console.WriteLine($"Discovered {printers.Count} Bluetooth printers.");
            discoveryComplete = true;
        }

        public void FoundPrinter(DiscoveredPrinter printer) {
            printers.Add(printer);
        }

        public bool DiscoveryComplete {
            get => discoveryComplete;
        }
    }
}
```

--------------------------------

### Print an Image Using GraphicsUtil

Source: https://techdocs.zebra.com/link-os/3-00/pc_net/content/html/b0eaf3f3-4c55-578e-b184-fc27c002445d

Example demonstrating how to connect to a printer and print an image file using the GraphicsUtil interface.

```C#
using System;
using System.IO;
using Zebra.Sdk.Comm;
using Zebra.Sdk.Printer;

public class GraphicsUtilExample {

    public static void Main(string[] args) {
        Connection connection = new TcpConnection("192.168.1.32", TcpConnection.DEFAULT_ZPL_TCP_PORT);
        try {
            connection.Open();
            ZebraPrinter printer = ZebraPrinterFactory.GetInstance(connection);

            int x = 0;
            int y = 0;
            printer.PrintImage("/path/to/my/image/sample.jpg", x, y);
        } catch (ConnectionException e) {
            Console.WriteLine(e.ToString());
        } catch (ZebraPrinterLanguageUnknownException e) {
            Console.WriteLine(e.ToString());
        } catch (IOException e) {
            Console.WriteLine(e.ToString());
        } finally {
            connection.Close();
        }
    }
}
```

--------------------------------

### Retrieve Configured Printer Alerts

Source: https://techdocs.zebra.com/link-os/3-00/pc_net/content/html/2c1f9c03-57e4-8791-a837-06d81ca0053d

Example demonstrating how to connect to a printer and retrieve its currently configured alerts using the AlertProvider functionality.

```C#
using System;
using System.Collections.Generic;
using Zebra.Sdk.Comm;
using Zebra.Sdk.Device;
using Zebra.Sdk.Printer;

public class AlertProviderExample {

    public static void Main(string[] args) {
        TcpConnection connection = new TcpConnection("192.168.1.32", TcpConnection.DEFAULT_ZPL_TCP_PORT);

        try {
            connection.Open();

            ZebraPrinter genericPrinter = ZebraPrinterFactory.GetInstance(connection);
            ZebraPrinterLinkOs linkOsPrinter = ZebraPrinterFactory.CreateLinkOsPrinter(genericPrinter);
            if (linkOsPrinter != null) {
                List<PrinterAlert> alerts = linkOsPrinter.GetConfiguredAlerts();
                foreach (PrinterAlert thisAlert in alerts) {
                    Console.WriteLine($"{thisAlert.Condition} {thisAlert.DestinationAsSgdString}");
                }
            }
        } catch (ConnectionException e) {
            Console.WriteLine(e.ToString());
        } catch (ZebraPrinterLanguageUnknownException e) {
            Console.WriteLine(e.ToString());
        } catch (ZebraIllegalArgumentException e) {
            Console.WriteLine(e.ToString());
        } finally {
            connection.Close();
        }
    }
}
```

--------------------------------

### PrinterAlert Usage Example

Source: https://techdocs.zebra.com/link-os/3-00/pc_net/content/html/4a7d8809-dec9-df0a-4a6f-edc5b4b85548

Demonstrates creating a PrinterAlert instance and accessing its properties for a ZPL printer.

```C#
using System;
using Zebra.Sdk.Printer;
using Zebra.Sdk.Settings;

public class PrinterAlertExample {

    public static void Main(string[] args) {
        PrinterAlert myPrinterAlert = new PrinterAlert(AlertCondition.PAPER_OUT, AlertDestination.TCP, true, false, "10.3.4.5", 9100, false);
        PrinterAlert myGenericAlert = myPrinterAlert;

        Console.WriteLine("Alert Info:");
        Console.WriteLine("  Condition = " + myGenericAlert.Condition);
        Console.WriteLine("  Destination = " + myGenericAlert.DestinationAsSgdString);
        Console.WriteLine("  Address = " + myGenericAlert.DestinationAddress);
        Console.WriteLine("  Port = " + myGenericAlert.Port);
        Console.WriteLine("  Fire when condition occurs? = " + myPrinterAlert.OnSet);
        Console.WriteLine("  Fire when condition clears? = " + myPrinterAlert.OnClear);
        Console.WriteLine("  Are alerts quelled? = " + myPrinterAlert.Quelling);
    }
}
```

--------------------------------

### Check Printer Status Example

Source: https://techdocs.zebra.com/link-os/3-00/pc_net/content/html/30526783-a973-1a1f-e89a-104ed24dbe89

Demonstrates how to connect to a printer and evaluate its current status using the PrinterStatus class.

```C#
using System;
using Zebra.Sdk.Comm;
using Zebra.Sdk.Printer;

public class PrinterStatusExample {

    public static void Main(string[] args) {
        Connection connection = new TcpConnection("192.168.1.100", TcpConnection.DEFAULT_ZPL_TCP_PORT);
        try {
            connection.Open();
            ZebraPrinter printer = ZebraPrinterFactory.GetInstance(connection);

            PrinterStatus printerStatus = printer.GetCurrentStatus();
            if (printerStatus.isReadyToPrint) {
                Console.WriteLine("Ready To Print");
            } else if (printerStatus.isPaused) {
                Console.WriteLine("Cannot Print because the printer is paused.");
            } else if (printerStatus.isHeadOpen) {
                Console.WriteLine("Cannot Print because the printer head is open.");
            } else if (printerStatus.isPaperOut) {
                Console.WriteLine("Cannot Print because the paper is out.");
            } else {
                Console.WriteLine("Cannot Print.");
            }
        } catch (ConnectionException e) {
            Console.WriteLine(e.ToString());
        } catch (ZebraPrinterLanguageUnknownException e) {
            Console.WriteLine(e.ToString());
        } finally {
            connection.Close();
        }
    }
}
```

--------------------------------

### CPCL Format Example

Source: https://techdocs.zebra.com/link-os/3-00/pc_net/content/html/bcbef86f-bd08-475f-9a05-1ddb442ba403

Example of a CPCL format containing variable fields.

```text
! DF SHELF.FMT
            ! 0 200 200 210 1
            CENTER
            TEXT 4 3 0 15 \
            TEXT 4 0 0 95 \
            FORM
            PRINT
```

--------------------------------

### MultichannelTcpConnection Usage Examples

Source: https://techdocs.zebra.com/link-os/3-00/pc_net/content/html/f14f7b2c-fd5e-5933-373a-2c709007e607

Demonstrates how to instantiate a MultichannelTcpConnection for simultaneous printing and status reporting, including both standard usage and non-blocking status checks.

```C#
using System;
using Zebra.Sdk.Comm;
using Zebra.Sdk.Printer;

public class MultichannelTcpConnectionExample {

    public static void Main(string[] args) {
        new MultichannelTcpConnectionExample().SimpleExample("1.2.3.4");
        new MultichannelTcpConnectionExample().NonBlockingStatusReporting("1.2.3.4");
    }

    private void SimpleExample(string theIpAddress) {
        // Instantiate Multichannel connection for simultaneous printing and status reporting at given address
        Connection thePrinterConn = new MultichannelTcpConnection(theIpAddress, MultichannelTcpConnection.DEFAULT_MULTICHANNEL_PRINTING_PORT, MultichannelTcpConnection.DEFAULT_MULTICHANNEL_STATUS_PORT);

        try {
            // Opens the connection - physical connection is established here.
            thePrinterConn.Open();

            // Creates a Link-OS printing with the given connection
            ZebraPrinterLinkOs linkOsPrinter = ZebraPrinterFactory.GetLinkOsPrinter(thePrinterConn);

            // This is sent over the printing channel (9100 by default)
            linkOsPrinter.PrintConfigurationLabel();

            // This is sent over the status channel (9200 by default)
            PrinterStatus status = linkOsPrinter.GetCurrentStatus();

            Console.WriteLine("The printer PAUSED state is : " + status.isPaused);
        } catch (ConnectionException e) {
            // Handle communications error here.
            Console.WriteLine(e.ToString());
        } finally {
            // Close the connection to release resources.
            thePrinterConn.Close();
        }
    }

    private void NonBlockingStatusReporting(string theIpAddress) {
        // Instantiate Multichannel connection for simultaneous printing and status reporting at given address
        Connection thePrinterConn = new MultichannelTcpConnection(theIpAddress, MultichannelTcpConnection.DEFAULT_MULTICHANNEL_PRINTING_PORT, MultichannelTcpConnection.DEFAULT_MULTICHANNEL_STATUS_PORT);

        try {
            // Opens the connection - physical connection is established here.
            thePrinterConn.Open();

            // Creates a Link-OS printing with the given connection
            ZebraPrinterLinkOs linkOsPrinter = ZebraPrinterFactory.GetLinkOsPrinter(thePrinterConn);

            // This is sent over the printing channel (9100 by default) and will block the printing channel until the
            // label format is completely sent.
            string labelFormatStartCommand = "^XA";
            linkOsPrinter.SendCommand(labelFormatStartCommand);

            string labelBody = "^FO20,20^A0N,25,25^FDThis is a ZPL test.^FS";
            linkOsPrinter.SendCommand(labelBody);

            // This is sent over the status channel (9200 by default) and will return immediately even though the
            // printing channel is in use.
            // If a TcpConnection were used instead of a MultichannelTcpConnection, this would not be possible.
            PrinterStatus status = linkOsPrinter.GetCurrentStatus();

            Console.WriteLine("The printer PAUSED state is : " + status.isPaused);

            // Send the end of label command to finish and print the label.
            string labelFormatEndCommand = "^XZ";
            linkOsPrinter.SendCommand(labelFormatEndCommand);
        } catch (ConnectionException e) {
            // Handle communications error here.
            Console.WriteLine(e.ToString());
        } finally {
            // Close the connection to release resources.
            thePrinterConn.Close();
        }
    }
}
```

--------------------------------

### Setting.Clone Property

Source: https://techdocs.zebra.com/link-os/3-00/pc_net/content/html/599f8df0-7b08-19d5-9c04-ee68baa9b7f2

Gets or sets if this setting can be applied when loading a profile.

```APIDOC
## Setting.Clone Property

### Description
Gets or sets if this setting can be applied when loading a profile.

### Property Value
Boolean

### Syntax
C#:
[JsonPropertyAttribute(PropertyName = "clone")]
public bool Clone { get; set; }

VB:
<JsonPropertyAttribute(PropertyName := "clone")>
Public Property Clone As Boolean

C++:
[JsonPropertyAttribute(PropertyName = L"clone")]
property bool Clone {
	bool get ();
	void set (bool value);
}
```

--------------------------------

### Print Stored Format with Variables and Graphics

Source: https://techdocs.zebra.com/link-os/3-00/pc_net/content/html/8e233e48-4c93-7fd2-2b2d-2fd1373d25cd

Example demonstrating how to print a stored format on a Link-OS printer by providing dictionaries for variable text and image data.

```C#
using System;
using System.Collections.Generic;
using System.IO;
using Zebra.Sdk.Comm;
using Zebra.Sdk.Graphics;
using Zebra.Sdk.Printer;

public class FormatUtilLinkOsExample {

    /// Print a stored format with the given variables.
    /// 
    /// The following ZPL will store a format on the Link-OS™ printer.
    /// 
    /// ^XA
    /// ^DFE:FORMAT2.ZPL
    /// ^FS
    /// ^FT26,243^A0N,56,55^FH\^FN12"First Name"^FS
    /// ^FT26,296^A0N,56,55^FH\^FN11"Last Name"^FS
    /// ^FT258,73^A0N,39,38^FH\^FDVisitor^FS
    /// ^FO100,100^XG^FN13,1,1^FS
    /// ^FO5,17^GB601,379,8^FS
    /// ^XZ
    public static void Main(string[] args) {
        string pathToImageFileOnHost = "/path/to/my/image/example.png";
        Connection connection = new TcpConnection("1.2.3.4", TcpConnection.DEFAULT_ZPL_TCP_PORT);
        try {
            connection.Open();

            Dictionary<int, string> vars = new Dictionary<int, string> {
                { 12, "John" },
                { 11, "Smith" }
            };

            ZebraImageI image = ZebraImageFactory.GetImage(pathToImageFileOnHost);
            Dictionary<int, ZebraImageI> imgVars = new Dictionary<int, ZebraImageI> {
                { 13, image }
            };

            ZebraPrinter genericPrinter = ZebraPrinterFactory.GetInstance(connection);
            ZebraPrinterLinkOs linkOsPrinter = ZebraPrinterFactory.CreateLinkOsPrinter(genericPrinter);
            if (linkOsPrinter != null) {
                linkOsPrinter.PrintStoredFormatWithVarGraphics("E:FORMAT2.ZPL", imgVars, vars);
            }
        } catch (ConnectionException e) {
            Console.WriteLine(e.ToString());
        } catch (ZebraPrinterLanguageUnknownException e) {
            Console.WriteLine(e.ToString());
        } catch (IOException e) {
            Console.WriteLine(e.ToString());
        } finally {
            connection.Close();
        }
    }
}
```

--------------------------------

### Download TTF Font Example

Source: https://techdocs.zebra.com/link-os/3-00/pc_net/content/html/731fa436-1bb5-c19c-3b02-5ba5cea90b87

Demonstrates how to use FontUtil to download a TrueType font file to a printer using a TCP connection.

```C#
using System;
using Zebra.Sdk.Comm;
using Zebra.Sdk.Printer;

public class FontUtilExample {

    public static void Main(string[] args) {
        TcpConnection connection = new TcpConnection("192.168.1.32", TcpConnection.DEFAULT_ZPL_TCP_PORT);

        try {
            connection.Open();

            ZebraPrinter genericPrinter = ZebraPrinterFactory.GetInstance(connection);
            ZebraPrinterLinkOs linkOsPrinter = ZebraPrinterFactory.CreateLinkOsPrinter(genericPrinter);
            if (linkOsPrinter != null) {
                linkOsPrinter.DownloadTtfFont("C:\\BaroqueScript.ttf", "E:Baroque");
            }
        } catch (ConnectionException e) {
            Console.WriteLine(e.ToString());
        } catch (ZebraPrinterLanguageUnknownException e) {
            Console.WriteLine(e.ToString());
        } finally {
            connection.Close();
        }
    }
}
```

--------------------------------

### Read Magnetic Card Data

Source: https://techdocs.zebra.com/link-os/3-00/pc_net/content/html/2ee4ed1f-69fd-4b57-236b-3abcf5db561a

Example demonstrating how to initialize a connection, create a MagCardReader instance, and read card data with a specified timeout.

```C#
using System;
using Zebra.Sdk.Comm;
using Zebra.Sdk.Device;
using Zebra.Sdk.Printer;

public class MagCardReaderExample {

    public static void Main(string[] args) {
        Connection connection = new TcpConnection("192.168.1.100", TcpConnection.DEFAULT_CPCL_TCP_PORT);

        try {
            connection.Open();
            ZebraPrinter printer = ZebraPrinterFactory.GetInstance(connection);
            MagCardReader mcr = MagCardReaderFactory.Create(printer);
            if (mcr != null) {
                string[] trackData = mcr.Read(10 * 1000);
                Console.WriteLine("Track1: " + trackData[0]);
                Console.WriteLine("Track2: " + trackData[1]);
                Console.WriteLine("Track3: " + trackData[2]);
            }
        } catch (ConnectionException e) {
            Console.WriteLine(e.ToString());
        } catch (ZebraPrinterLanguageUnknownException e) {
            Console.WriteLine(e.ToString());
        } finally {
            connection.Close();
        }
    }
}
```

--------------------------------

### CsvPrinter Usage Example

Source: https://techdocs.zebra.com/link-os/3-00/pc_net/content/html/06c000ce-024d-5d39-608a-98227fe05bf7

Demonstrates how to use the CsvPrinter class to print data, including handling destination devices and output streams.

```C#
using System;
using System.IO;
using System.Text;
using Zebra.Sdk.Printer;

public class CsvPrinterExample {

    public static void Main(string[] args) {
        CsvPrintingExample();
        CnCsvPrintingExample();
    }

    /// These examples demonstrate how to use the one-line printing capability of the CsvPrinter class.
    /// 
    /// They assume that a ZPL template containing variable fields appropriate to the CSV data
    /// specified exists on the host device. In this case, a PC with the file named CsvPrinterExampleTemplate.zpl
    /// saved at "c:\CsvPrinterExampleTemplate.zpl". The contents of this file should be...
    /// 
    /// ^XA^DFCsvExamp.zpl^FS
    /// ^A0N,100,100^FO100,100^FN1"Name"^FS
    /// ^A0N,100,100^FO100,200^FN2"Street"^FS
    /// ^A0N,100,100^FO100,300^FN3"City"^FS
    /// ^A0N,100,100^FO100,400^FN4"State"^FS
    /// ^A0N,100,100^FO100,500^FN5"Zip"^FS
    /// ^XZ
    public static void CsvPrintingExample() {
        // The possible inputs to the one-line CSV printing function(s)

        string destinationDevice = "192.168.1.32";

        string templateFilename = "c:\\CsvPrinterExampleTemplate.zpl";
        string defaultQuantityString = "1";
        bool verbose = true;

        // If the destination device argument is 'null' then any data that would have been sent to a destination device,
        // had one been specified, is captured in 'outputDataStream'. This provides a way to test your output and
        // configuration without having an actual printer available or without wasting media even if a printer is
        // available.

        Console.WriteLine("\nThe destinationDevice connection string argument is null:");
        try {
            using (MemoryStream outputDataStream = new MemoryStream()) {
                using (MemoryStream sourceDataStream = GetSampleCsvData()) {
                    CsvPrinter.Print(null, sourceDataStream, templateFilename, defaultQuantityString, outputDataStream, verbose);
                    Console.WriteLine(Encoding.UTF8.GetString(outputDataStream.ToArray()));
                }
            }
        } catch (Exception e) {
            Console.WriteLine(e.ToString());
        }

        // The outputDataStream argument may be null, in which case the data generated by the CsvPrinter class will
        // not be logged but will be sent to the destination device.
        Console.WriteLine("\nThe outputDataStream argument is null:");
        try {
            using (MemoryStream sourceDataStream = GetSampleCsvData()) {
                CsvPrinter.Print(destinationDevice, sourceDataStream, templateFilename, defaultQuantityString, null, verbose);
            }
        } catch (Exception e) {
            Console.WriteLine(e.ToString());
        }

        // Both destinationDevice connection string AND outputDataStream arguments may be specified, in which case the
        // data generated by the CsvPrinter class will be sent to the destination device and logged to the
        // outputDataStream.
        Console.WriteLine("\nBoth destinationDevice connection string and outputDataStream arguments are specified:");
        try {
            using (MemoryStream outputDataStream = new MemoryStream()) {
                using (MemoryStream sourceDataStream = GetSampleCsvData()) {
                    CsvPrinter.Print(destinationDevice, sourceDataStream, templateFilename, defaultQuantityString, outputDataStream, verbose);
                    Console.WriteLine(Encoding.UTF8.GetString(outputDataStream.ToArray()));
                }
            }
        } catch (Exception e) {
            Console.WriteLine(e.ToString());
        }
```

--------------------------------

### GetDiscoveryDataMap Usage Example

Source: https://techdocs.zebra.com/link-os/3-00/pc_net/content/html/1547fce1-1f0b-39f7-98fa-6195a8d4b385

Demonstrates using GetDiscoveryDataMap to retrieve printer firmware version information over a TCP connection.

```C#
using System;
using System.Collections.Generic;
using Zebra.Sdk.Comm;
using Zebra.Sdk.Printer.Discovery;

public class DiscoveryUtilExample {

    public static void Main(string[] args) {
        // Instantiate connection for ZPL TCP port at given address
        Connection connection = new TcpConnection("192.168.1.1", TcpConnection.DEFAULT_ZPL_TCP_PORT);

        try {
            // Open the connection - physical connection is established here.
            connection.Open();

            Dictionary<string, string> discoveryData = DiscoveryUtil.GetDiscoveryDataMap(connection);
            Console.WriteLine($"The printer's firmware version is: {discoveryData["FIRMWARE_VER"]}");
        } catch (ConnectionException e) {
            // Handle communications error here.
            Console.WriteLine(e.ToString());
        } catch (DiscoveryPacketDecodeException e) {
            Console.WriteLine(e.ToString());
        } finally {
            // Close the connection to release resources.
            connection.Close();
        }
    }
}
```

--------------------------------

### Retrieve Printer Status Messages

Source: https://techdocs.zebra.com/link-os/3-00/pc_net/content/html/8185ebec-36a7-0dc0-9ce5-d45acf48c901

Example demonstrating how to check printer status and retrieve human-readable messages when the printer is not ready.

```C#
using System;
using Zebra.Sdk.Comm;
using Zebra.Sdk.Printer;

public class PrinterStatusMessagesExample {

    public static void Main(string[] args) {
        Connection connection = new TcpConnection("192.168.1.100", TcpConnection.DEFAULT_ZPL_TCP_PORT);
        try {
            connection.Open();
            ZebraPrinter printer = ZebraPrinterFactory.GetInstance(connection);

            PrinterStatus printerStatus = printer.GetCurrentStatus();

            if (printerStatus.isReadyToPrint) {
                Console.WriteLine("Ready To Print");
            } else {
                PrinterStatusMessages statusMessage = new PrinterStatusMessages(printerStatus);
                string[] statusMessages = statusMessage.GetStatusMessage();
                string joinedStatusMessage = "";
                for (int i = 0; i < statusMessages.Length; i++) {
                    joinedStatusMessage += statusMessages[i] + ";";
                }
                Console.WriteLine($"Cannot Print: {joinedStatusMessage}");
            }
        } catch (ConnectionException e) {
            Console.WriteLine(e.ToString());
        } catch (ZebraPrinterLanguageUnknownException e) {
            Console.WriteLine(e.ToString());
        } finally {
            connection.Close();
        }
    }
}
```

--------------------------------

### Discover Printers on Network

Source: https://techdocs.zebra.com/link-os/3-00/pc_net/content/html/f0bd72a6-c982-2f1f-f4d3-d54caefae70c

Example implementation of printer discovery using the NetworkDiscoverer class and a custom DiscoveryHandler.

```C#
using System;
using System.Collections.Generic;
using Zebra.Sdk.Printer.Discovery;

public class NetworkDiscovererExample {

    public static void Main(string[] args) {
        try {
            Console.WriteLine("Starting printer discovery.");

            NetworkDiscoveryHandler discoveryHandler = new NetworkDiscoveryHandler();
            NetworkDiscoverer.FindPrinters(discoveryHandler);
            while (!discoveryHandler.DiscoveryComplete) {
                System.Threading.Thread.Sleep(10);
            }
        } catch (DiscoveryException e) {
            Console.WriteLine(e.ToString());
        }
    }

    private class NetworkDiscoveryHandler : DiscoveryHandler {

        private bool discoveryComplete = false;
        List<DiscoveredPrinter> printers = new List<DiscoveredPrinter>();

        public void DiscoveryError(string message) {
            Console.WriteLine($"An error occurred during discovery: {message}.");
            discoveryComplete = true;
        }

        public void DiscoveryFinished() {
            foreach (DiscoveredPrinter printer in printers) {
                Console.WriteLine(printer);
            }
            Console.WriteLine($"Discovered {printers.Count} Link-OS™ printers.");
            discoveryComplete = true;
        }

        public void FoundPrinter(DiscoveredPrinter printer) {
            printers.Add(printer);
        }

        public bool DiscoveryComplete {
            get => discoveryComplete;
        }
    }
}
```

--------------------------------

### Connection.SimpleConnectionName Property

Source: https://techdocs.zebra.com/link-os/3-00/pc_net/content/html/e6f35cef-fdc2-0b27-91b6-ba97310903b8

Gets a human-readable description of the connection.

```APIDOC
## Connection.SimpleConnectionName Property

### Description
Gets a human-readable description of the connection.

### Namespace
Zebra.Sdk.Comm

### Property Value
String

### Syntax
C#:
string SimpleConnectionName { get; }

VB:
ReadOnly Property SimpleConnectionName As String

C++:
property String^ SimpleConnectionName { String^ get (); }
```

--------------------------------

### XmlPrinter Usage Example

Source: https://techdocs.zebra.com/link-os/3-00/pc_net/content/html/8026e23d-26d4-5bd2-9f3e-a29cda0e523b

Demonstrates how to use the XmlPrinter class to print XML data using a ZPL template, including handling of destination devices and output streams.

```C#
using System;
using System.IO;
using System.Text;
using Zebra.Sdk.Printer;

public class XmlPrinterExample {

    public static void Main(string[] args) {
        XmlPrintingExample();
        CnXmlPrintingExample();
    }

    /// These examples demonstrate how to use the one-line printing capability of the XmlPrinter class.
    ///
    /// They assume that a ZPL template containing variable fields appropriate to the XML data
    /// specified exists on the host device. In this case, a PC with the file named XmlPrinterExampleTemplate.zpl
    /// saved at "c:\XmlPrinterExampleTemplate.zpl". The contents of this file should be...
    /// 
    /// ^XA^DFXmlExamp.zpl^FS
    /// ^A0N,100,100^FO100,100^FN1"Name"^FS
    /// ^A0N,100,100^FO100,200^FN2"Street"^FS
    /// ^A0N,100,100^FO100,300^FN3"City"^FS
    /// ^A0N,100,100^FO100,400^FN4"State"^FS
    /// ^A0N,100,100^FO100,500^FN5"Zip"^FS
    /// ^XZ
    private static void XmlPrintingExample() {
        // The possible inputs to the one-line XML printing function(s)
        string destinationDevice = "192.168.1.32";

        string templateFilename = "c:\\XmlPrinterExampleTemplate.zpl";
        string defaultQuantityString = "1";
        bool verbose = true;

        // If the destination device argument is 'null' then any data that would have been
        // sent to a destination device, had one been specified, is captured in 'outputDataStream'.
        // This provides a way to test your output and configuration without having an actual
        // printer available or without wasting media even if a printer is available.
        Console.WriteLine("\nThe destinationDevice connection string argument is null:");
        try {
            using (MemoryStream outputDataStream = new MemoryStream()) {
                using (Stream sourceStream = GetSampleXmlData()) {
                    XmlPrinter.Print(null, sourceStream, templateFilename, defaultQuantityString, outputDataStream, verbose);
                    Console.WriteLine(Encoding.UTF8.GetString(outputDataStream.ToArray()));
                }
            }
        } catch (Exception e) {
            Console.WriteLine(e.ToString());
        }

        // The outputDataStream argument may be null, in which case the data generated by the XmlPrinter class will
        // not be logged but will be sent to the destination device.
        Console.WriteLine("\nThe outputDataStream argument is null:");
        try {
            using (Stream sourceStream = GetSampleXmlData()) {
                XmlPrinter.Print(destinationDevice, sourceStream, templateFilename, defaultQuantityString, null, verbose);
            }
        } catch (Exception e) {
            Console.WriteLine(e.ToString());
        }

        // Both destinationDevice connection string AND outputDataStream arguments may be specified, in which case the
        // data generated by the XmlPrinter class will be sent to the destination device and logged to the outputDataStream.
        Console.WriteLine("\nBoth destinationDevice connection string and outputDataStream arguments are specified:");
        try {
            using (MemoryStream outputDataStream = new MemoryStream()) {
                using (Stream sourceStream = GetSampleXmlData()) {
                    XmlPrinter.Print(destinationDevice, sourceStream, templateFilename, defaultQuantityString, outputDataStream, verbose);
                    Console.WriteLine(Encoding.UTF8.GetString(outputDataStream.ToArray()));
                }
            }
        } catch (Exception e) {
            Console.WriteLine(e.ToString());
        }
```

--------------------------------

### ConnectionA.SimpleConnectionName Property

Source: https://techdocs.zebra.com/link-os/3-00/pc_net/content/html/9eb2e598-0bca-ff57-70e5-0acc178968e2

Gets a human-readable description of the connection.

```APIDOC
## Property: SimpleConnectionName

### Description
Gets a human-readable description of the connection.

### Namespace
Zebra.Sdk.Comm

### Property Value
- **Type**: String

### Syntax
- **C#**: `public virtual string SimpleConnectionName { get; }`
- **VB**: `Public Overridable ReadOnly Property SimpleConnectionName As String`
- **C++**: `public: virtual property String^ SimpleConnectionName { String^ get (); }`
```

--------------------------------

### UsbConnection.SimpleConnectionName Property

Source: https://techdocs.zebra.com/link-os/3-00/pc_net/content/html/0b306ec0-4399-7915-dcec-b88f7c90243a

Gets a human-readable description of the connection.

```APIDOC
## UsbConnection.SimpleConnectionName Property

### Description
Gets a human-readable description of the connection.

### Property Value
- **Type**: String

### Syntax
- **C#**: `public override string SimpleConnectionName { get; }`
- **VB**: `Public Overrides ReadOnly Property SimpleConnectionName As String`
- **C++**: `public: virtual property String^ SimpleConnectionName { String^ get () override; }`
```

--------------------------------

### Open()

Source: https://techdocs.zebra.com/link-os/3-00/pc_net/content/html/6de0ff2a-3569-5c6b-95ec-647eff1b6c9a

Establishes the physical connection to the printer.

```APIDOC
## Open()

### Description
Opens the connection to the printer, establishing the physical link.
```

--------------------------------

### LinkOsInformation.Major Property

Source: https://techdocs.zebra.com/link-os/3-00/pc_net/content/html/28665e24-1e83-cc99-386e-cf55e2e1d625

Gets the Link-OS major version number.

```APIDOC
## LinkOsInformation.Major Property

### Description
Gets the Link-OS major version number.

### Syntax

#### C#
```csharp
public int Major { get; }
```

#### VB
```vb
Public ReadOnly Property Major As Integer
	Get
```

#### C++
```cpp
public:
property int Major {
	int get ();
}
```

### Property Value
- **Type**: Int32

### Namespace
Zebra.Sdk.Printer
```
Tokens:
Raw