using (ITikConnection connection = ConnectionFactory.CreateConnection(TikConnectionType.Api))
{
  connection.Open(HOST, USER, PASS);
  ITikCommand cmd = connection.CreateCommand("/system/identity/print");
  Console.WriteLine(cmd.ExecuteScalar());
}

using (ITikConnection connection = ConnectionFactory.CreateConnection(TikConnectionType.Api))
{
  connection.Open(HOST, USER, PASS);
  var loadingContext = connection.LoadAsync<ToolTorch>(
    torchItem => Console.WriteLine(torchItem.ToString()),
    error => Console.WriteLine(error.ToString()),                                                
    connection.CreateParameter("interface", interfaceName),   
    connection.CreateParameter("port", "any"),
    connection.CreateParameter("src-address", "0.0.0.0/0"),
    connection.CreateParameter("dst-address", "0.0.0.0/0"));

  Console.ReadLine();
  loadingContext.Cancel();
}

var logs = connection.LoadList<Log>();
foreach (Log log in logs)
{
    Console.WriteLine("{0}[{1}]: {2}", log.Time, log.Topics, log.Message);
}

//find first firewall rule
var firstFirewallRule = connection.LoadAll<FirewallFilter>().First();

// create new firewall rule as first rule in list
var firewallFilter = new FirewallFilter()
{
   Chain = FirewallFilter.ChainType.Forward,
   Action = FirewallFilter.ActionType.Accept,
};
connection.Save(firewallFilter);
connection.Move(firewallFilter, firstFirewallRule);

// renew IP on dhcp-client interface
connection.LoadAll<IpDhcpClient>().First().Release(connection);

using tik4net.Objects;
using tik4net.Objects.Ip.Hotspot;

var user = new HotspotUser()
{
    Name = "TEST",
    LimitUptime = "1:00:00",
    Password = "secretpass"
};
_connection.Save(user);

var list = Connection.LoadAll<InterfaceWireless.WirelessRegistrationTable>();

using (ITikConnection connection = ConnectionFactory.CreateConnection(TikConnectionType.Api))
{
  connection.Open(HOST, USER, PASS);

  string[] command = new string[]
  {
    "/ip/firewall/connection/print",
    "?src-address=192.168.3.103"
  };
  var result = connection.CallCommandSync(command);

  var command = connection.CreateCommandAndParameters("/ip/firewall/connection/print",
    "src-address", "192.168.3.103");
  var result = command.ExecuteList();

  // This class will be part of the next release, but you can just put it in your code
    [TikEntity("ip/firewall/connection")]
    public class FirewallConnection
    {
        [TikProperty(".id", IsReadOnly = true, IsMandatory = true)]
        public string Id { get; private set; }

        [TikProperty("connection-mark", IsReadOnly = true)]
        public string ConnectionMark { get; private set; }

        [TikProperty("connection-type", IsReadOnly = true)]
        public string ConnectionType { get; private set; }

        [TikProperty("dst-address", IsReadOnly = true)]
        public string DstAddress { get; private set; }

        [TikProperty("protocol", IsReadOnly = true)]
        public string Protocol { get; private set; }

        [TikProperty("src-address", IsReadOnly = true)]
        public string SrcAddress { get; private set; }

        [TikProperty("tcp-state", IsReadOnly = true)]
        public string TcpState { get; private set; }

        [TikProperty("timeout", IsReadOnly = true)]
        public string Timeout { get; private set; }
    }

  // And the code:
  using tik4net.Objects;
  ...
  var result = connection. LoadList<FirewallConnection>(
    connection.CreateParameter("src-address", "192.168.3.103"));

var command = connection.CreateCommandAndParameters("/ip/firewall/connection/print"); 
var result = command.ExecuteList();

/interface/print
?type=ether
?type=vlan
?#|

            var cmd = Connection.CreateCommandAndParameters(@"/interface/print
                            ?type=ether
                            ?type=wlan
                            ?#|");
            var list = cmd.ExecuteList();

            var cmd = Connection.CreateCommandAndParameters(@"/interface/print
                            ?type=ether
                            ?type=wlan
                            ?#|");
            var list = cmd.LoadList<Interface>();

            var filter = new InterfaceBridge.BridgeFilter()
            {
                Chain = InterfaceBridge.BridgeFilter.ChainType.Forward,
                Action = InterfaceBridge.BridgeFilter.ActionType.Accept,
            };
            Connection.Save(filter);

            var nat = new InterfaceBridge.BridgeNat()
            {
                Chain = InterfaceBridge.BridgeFirewallBase.ChainType.Forward,
                Action = InterfaceBridge.BridgeNat.ActionType.Accept,
            };
            Connection.Save(nat);

    using (var conection = ConnectionFactory.OpenConnection(TikConnectionType.ApiSsl, host, user, pass))
    {
      // do something usefull
    }

Dim iface = con.CreateCommand("/interface/print")
Dim show = iface.ExecuteList()
        For Each eth In show
            lb1.Items.Add(eth)
        Next eth

Dim iface = con.CreateCommand("/interface/print")
Dim show = iface.ExecuteList()
        For Each eth In show
            lb1.Items.Add(eth.GetResponseField("name"))
        Next eth

using tik4net.Objects;
using tik4net.Objects.Interface;

Dim show = con.LoadAll<Interface>()
        For Each eth In show
            lb1.Items.Add(eth.Name)
        Next eth

Dim show = con.LoadAll<Interface>()

Dim show = con.LoadAll(Of [Interface])()

/interface set ether2 name=LAN 

var list = Connection.LoadAll<Interface>();
var eth = list.Where(iface => iface.DefaultName == "ether1").Single();
eth.Name = "newName";
Connection.Save(eth);

var cmd = Connection.CreateCommand("/interface/set");
cmd.AddParameter(TikSpecialProperties.Id, "ether1");
cmd.AddParameter("name", "newName");
cmd.ExecuteNonQuery();

/interface/set
.id=ether1
name=newName

    Public Sub IPread()
        Dim ipList = con.LoadList(Of Ip.IpAddress)().ToArray
        dgvIP.DataSource = ipList

        Me.dgvIP.Columns(3).HeaderText = "Interface"
        Me.dgvIP.Columns(2).HeaderText = "Address"
        Me.dgvIP.Columns(1).Visible = False
        Me.dgvIP.Columns(0).Visible = False
        Me.dgvIP.Columns(4).Visible = False
        Me.dgvIP.Columns(5).Visible = False
        Me.dgvIP.Columns(6).Visible = False
        Me.dgvIP.Columns(7).Visible = False
        Me.dgvIP.Columns(8).Visible = False
        Me.dgvIP.Columns(9).Visible = False
        Me.dgvIP.Columns(10).Visible = False
    End Sub 

Public Sub dnsRead()
Dim dnsList = con.LoadList(Of Ip.IpDns)().ToArray
dgvDNS.DataSource = dnsList
End Sub

Public Sub dnsRead()
        Dim dnsList = con.LoadList(Of Ip.IpDns)().ToArray
        For Each dns In dnsList
            lbDNS.Items.Add(dns.Servers)
        Next
End Sub

 string[] command = new string[]
            {
                "/interface/monitor-traffic",
                "=interface=ether5-hotspot",
                "=once="
            };
                    var result = connection.CallCommandSync(command);

 List<ITikReSentence> responses = new List<ITikReSentence>();
 // ....
 var cmd = Connection.CreateCommandAndParameters("/interface/monitor-traffic", "interface", "ether1");
 cmd.ExecuteAsync(re => responses.Add(re));
 
 // ....
 cmd.CancelAndJoin(); //stops the interface monitoring

const string HOST = "127.0.0.1";
const int MAX_CNT = 100;

List<ToolPing> responseList = new List<ToolPing>();
Exception responseException = null;

ITikCommand pingCommand = Connection.LoadAsync<ToolPing>(
  ping => responseList.Add(ping), //read callback
  exception => responseException = exception, //exception callback
  Connection.CreateParameter("address", HOST), Connection.CreateParameter("count", MAX_CNT.ToString()), Connection.CreateParameter("size", "64"));
// ...
Thread.Sleep(3 * 1000);
Connection.Close();

 ITikCommand cmdhotspot = conn.CreateCommand("/ip/hotspot/user/disable",
                                   conn.CreateParameter(".id", IserverHotspot._IDUser));

var listdisableduserwifi = conn.LoadList<HotspotUser>().Where(p => p.Name == IserverHotspot._NameUser).SingleOrDefault();
 listdisableduserwifi.Disableduser();

ITikCommand cmd = connection.CreateCommandAndParameters("/ppp/secret/set find[name=" + username + "] disable=yes"); 
cmd.ExecuteNonQuery();

// Retrieve the secret.
ITikReSentence secret = conn.CreateCommandAndParameters("/ppp/secret/print", "name", username).ExecuteSingleRow();

// Disable the secret.
conn.CreateCommandAndParameters("/ppp/secret/set", ".id", secret.Words[".id"], "disabled", "true").ExecuteNonQuery();

// Retrieve pptp secrets.
IEnumerable<ITikReSentence> secrets = conn.CreateCommandAndParameters("/ppp/secret/print", "service", "pptp").ExecuteList();

foreach (var secret in secrets)
{
  // Disable the secret.
  conn.CreateCommandAndParameters("/ppp/secret/set", ".id", secret.Words[".id"], "disabled", "true").ExecuteNonQuery();
}

ITikCommand smsCmd = connection.CreateCommand("/tool/sms/send", 
    connection.CreateParameter("port", "usb3"), 
    connection.CreateParameter("channel", "3"), 
    connection.CreateParameter("phone-number", "00420777123456"), // or "dst" instead of "phone-number" - depends on tik version ???
    connection.CreateParameter("message", "Test message.")    
);
smsCmd.ExecuteNonQuery();

Imports tik4net
Imports tik4net.Objects
Imports tik4net.Objects.Ip.Firewall

Namespace Test
	Public Class MyTest
		Public Sub TestMikrotik()	
			Using connection As ITikConnection = ConnectionFactory.CreateConnection(TikConnectionType.Api)
				connection.Open(HOST, USER, PASS)

				Dim cmd As ITikCommand = connection.CreateCommand("/system/identity/print")
				Dim identity = cmd.ExecuteScalar()
				Console.WriteLine("Identity: {0}", identity)

				Dim logs = connection.LoadList(Of Log)()
				For Each log As Log In logs
					Console.WriteLine("{0}[{1}]: {2}", log.Time, log.Topics, log.Message)
				Next

				Dim fwf = New FirewallFilter() With { _
					.Chain = FirewallFilter.ChainType.Forward, _
					.Action = FirewallFilter.ActionType.Accept _
				}
				connection.Save(fwf)
			End Using
		End Sub
	End Class
End Namespace

Imports tik4net
Imports tik4net.Objects


Namespace Test
   Public Class MyTest
      Public Sub TestMikrotik()   
         Using connection As ITikConnection = ConnectionFactory.CreateConnection(TikConnectionType.Api)
            connection.Open(HOST, USER, PASS)

            Dim cmd As ITikCommand = connection.CreateCommandAndParameters("/tool/user-manager/user/print")
            Dim results = cmd.ExecuteList()

            For Each users In results
                Console.WriteLine(users)
            Next users

         End Using
      End Sub
   End Class
End Namespace

        
        /// <summary>
        /// /ip/hotspot/profile/print: 
        /// </summary>
        [TikEntity("/ip/hotspot/profile/print")]
        public class ServerProfile
        {
            /// <summary>
            /// .tag: 
            /// </summary>
            [TikProperty(".tag")]
            public long Tag { get; set; }

            /// <summary>
            /// .id: 
            /// </summary>
            [TikProperty(".id", IsReadOnly = true, IsMandatory = true)]
            public string Id { get; private set; }

            /// <summary>
            /// name: 
            /// </summary>
            [TikProperty("name", IsMandatory = true)]
            public string Name { get; set; }

            /// <summary>
            /// hotspot-address: 
            /// </summary>
            [TikProperty("hotspot-address")]
            public string HotspotAddress { get; set; }

            /// <summary>
            /// html-directory: 
            /// </summary>
            [TikProperty("html-directory")]
            public string HtmlDirectory { get; set; }

            /// <summary>
            /// http-proxy: 
            /// </summary>
            [TikProperty("http-proxy")]
            public string HttpProxy { get; set; }

            /// <summary>
            /// smtp-server: 
            /// </summary>
            [TikProperty("smtp-server")]
            public string SmtpServer { get; set; }

            /// <summary>
            /// login-by: 
            /// </summary>
            [TikProperty("login-by")]
            public string LoginBy { get; set; }

            /// <summary>
            /// split-user-domain: 
            /// </summary>
            [TikProperty("split-user-domain")]
            public bool SplitUserDomain { get; set; }

            /// <summary>
            /// use-radius: 
            /// </summary>
            [TikProperty("use-radius")]
            public bool UseRadius { get; set; }

            /// <summary>
            /// default: 
            /// </summary>
            [TikProperty("default")]
            public bool Default { get; set; }

        }

            ITikCommand cmd = connection.CreateCommand("/ip/hotspot/profile/edit");
            cmd.AddParameter(TikSpecialProperties.Id, "0");
            cmd.AddParameter("name", "helloworld");
            cmd.ExecuteNonQuery();

Dim cmd As ITikCommand = connection.CreateCommandAndParameters("/tool/user-manager/user/add", "customer", "admin", "username", "test007", "password", "12345678")
cmd.ExecuteNonQuery()

Dim cmd As ITikCommand = connection.CreateCommandAndParameters("/tool/user-manager/user/create-and-activate-profile", "", "test007", "profile", "Always", "customer", "admin")
cmd.ExecuteNonQuery()

Dim cmd As ITikCommand = connection.CreateCommandAndParameters("/interface/ethernet/switch/mac-based-vlan/add", "src-mac-address","11:22:33:44:55:66", "new-customer-vid","14")

void Main()
{
  using (var conn = tik4net.ConnectionFactory.OpenConnection(TikConnectionType.Api, "192.168.88.1", 8728, "admin", "mypassword"))
  {
    var list = conn.LoadAll<PppActive>();
  }
}

[TikEntity("/ppp/active", IncludeDetails = true)]
public class PppActive
{
  [TikProperty(".id")]
  public string Id { get; private set; }

  [TikProperty("name")]
  public string Name { get; private set; }

  [TikProperty("service")]
  public string Service { get; private set; }

  [TikProperty("caller-id")]
  public string CallerId { get; private set; }

  [TikProperty("address")]
  public string Address { get; private set; }

  [TikProperty("uptime")]
  public string Uptime { get; private set; }

  [TikProperty("encoding")]
  public string Encoding { get; private set; }

  [TikProperty("session-id")]
  public string SessionId { get; private set; }

  [TikProperty("limit-bytes-in")]
  public int LimitBytesIn { get; private set; }

  [TikProperty("limit-bytes-out")]
  public int LimitBytesOut { get; private set; }

  [TikProperty("radius")]
  public bool Radius { get; private set; }
}

private void button1_Click(object sender, EventArgs e)
        {
            using (ITikConnection connection = ConnectionFactory.CreateConnection(TikConnectionType.Api))
            {
                connection.Open("192.168.77.xxx", "admin", "pass");

                ITikCommand certcmd = connection.CreateCommand("/certificate/add",
                    connection.CreateParameter("name", "test"),
                    connection.CreateParameter("common-name", "test.com"),
                    connection.CreateParameter("key-size", "2048"),
                    connection.CreateParameter("key-usage", "crl-sign,key-cert-sign"),
                    connection.CreateParameter("days-valid", "365"));
                
                certcmd.ExecuteAsync(response =>
                {
                    Console.WriteLine(response.GetResponseField(""));
                });
                Console.WriteLine("Certificate created - press ENTER");
                Console.ReadLine();
            }
        }

Using connection As ITikConnection = ConnectionFactory.CreateConnection(TikConnectionType.Api)
            connection.Open(Form2.HostTB.Text, Form2.LoginTB.Text, Form2.PassTB.Text)
            Dim cmd As ITikCommand = connection.CreateCommandAndParameters("/ip/hotspot/user/profile/remove")
            cmd.AddParameter(TikSpecialProperties.Id, CBdelprof.Text)
            cmd.ExecuteNonQuery()
            MessageBox.Show("Profile Deleted")

/ip hotspot user print count-only where comment=expired.user

connection.LoadAll<UserProfile>().Where(u=>u.Comment="expired.user").Count();

connection.Open(HOST, PORT, USER, PASS);

var ethIface = Connection.LoadSingle<Interface>(Connection.CreateParameter("name", "ether1"));
var rx = ethIface.RxByte;

        /// <summary>
        /// Gets snapshot of actual traffic RX/TX values for given <paramref name="interfaceName"/>.
        /// </summary>
        public static InterfaceMonitorTraffic GetInterfaceMonitorTrafficSnapshot(ITikConnection connection, string interfaceName)
        {
            var cmd = connection.CreateCommand("/interface/monitor-traffic",
                connection.CreateParameter("interface", interfaceName, TikCommandParameterFormat.NameValue),
                connection.CreateParameter("once", "", TikCommandParameterFormat.NameValue));
            var result = cmd.LoadList<InterfaceMonitorTraffic>().Single();

            return result;
        }
     

    /// <summary>
    /// /interface/monitor-traffic
    /// NOTE: use <see cref="InterfaceMonitorTraffic.GetSnapshot"/> or with some kind of bulk/async load
    /// </summary>
    [TikEntity("/interface", IncludeDetails = true, IsReadOnly = true)]
    public class InterfaceMonitorTraffic
    {
        /// <summary>
        /// name
        /// </summary>
        [TikProperty("name", IsMandatory = true, IsReadOnly = true)]
        public string Name { get; private set; }

        /// <summary>
        /// rx-packets-per-second
        /// </summary>
        [TikProperty("rx-packets-per-second", IsMandatory = true, IsReadOnly = true)]
        public string RxPacketsPerSecond { get; private set; }

        /// <summary>
        /// rx-bits-per-second
        /// </summary>
        [TikProperty("rx-bits-per-second", IsMandatory = true, IsReadOnly = true)]
        public string RxBitsPerSecond { get; private set; }

        /// <summary>
        /// rx-drops-per-second
        /// </summary>
        [TikProperty("rx-drops-per-second", IsMandatory = true, IsReadOnly = true)]
        public string RxSropsPerSecond { get; private set; }

        /// <summary>
        /// rx-errors-per-second
        /// </summary>
        [TikProperty("rx-errors-per-second", IsMandatory = true, IsReadOnly = true)]
        public string RxErrorsPerSecond { get; private set; }        

        /// <summary>
        /// tx-packets-per-second
        /// </summary>
        [TikProperty("tx-packets-per-second", IsMandatory = true, IsReadOnly = true)]
        public string TxPacketsPerSecond { get; private set; }

        /// <summary>
        /// tx-bits-per-second
        /// </summary>
        [TikProperty("tx-bits-per-second", IsMandatory = true, IsReadOnly = true)]
        public string TxBitsPerSecond { get; private set; }

        /// <summary>
        /// tx-drops-per-second
        /// </summary>
        [TikProperty("tx-drops-per-second", IsMandatory = true, IsReadOnly = true)]
        public string TxSropsPerSecond { get; private set; }

        /// <summary>
        /// tx-errors-per-second
        /// </summary>
        [TikProperty("tx-errors-per-second", IsMandatory = true, IsReadOnly = true)]
        public string TxErrorsPerSecond { get; private set; }
    }

connection.LoadList(Of HotspotUser)()

var user = new HotspotUser()
{
    Name = "TEST",
    LimitUptime = "1:00:00",
    Password = "secretpass"
};
_connection.Save(user);

            ITikCommand printcmd = connection.CreateCommand("/ip/ipsec/remote-peer/print");
            IEnumerable<ITikReSentence> userlist = printcmd.ExecuteList();

            ITikReSentence id = connection.CreateCommandAndParameters("/ip/ipsec/remote-peers/print", "id", username).ExecuteSingleRow();

/ip firewall filter
add chain=input dst-port=8728 in-interface-list=LAN protocol=tcp src-address=192.168.88.0/24

namespace tik4net.Objects.Ip.Hotspot
{
    /// <summary>
    /// ip/hotspot/ip-binding
    /// 
    /// IP-Binding HotSpot menu allows to setup static One-to-One NAT translations, allows to bypass specific HotSpot clients without any authentication, and also allows to block specific hosts and subnets from HotSpot network 
    /// </summary>
    [TikEntity("ip/hotspot/ip-binding")]
    public class HotspotIpBinding
    {
        /// <summary>
        /// .id: primary key of row
        /// </summary>
        [TikProperty(".id", IsReadOnly = true, IsMandatory = true)]
        public string Id { get; private set; }

        /// <summary>
        /// address: The original IP address of the client
        /// </summary>
        [TikProperty("address", DefaultValue = "")]
        public string/*IP Range*/ Address { get; set; }

        /// <summary>
        /// mac-address: MAC address of the client
        /// </summary>
        [TikProperty("mac-address", DefaultValue = "")]
        public string/*MAC*/ MacAddress { get; set; }

        /// <summary>
        /// server
        /// Name of the HotSpot server.
        ///  all - will be applied to all hotspot servers
        /// </summary>
        [TikProperty("server", DefaultValue = "all")]
        public string/*string | all*/ Server { get; set; }

        /// <summary>
        /// to-address: New IP address of the client, translation occurs on the router (client does not know anything about the translation)
        /// </summary>
        [TikProperty("to-address", DefaultValue = "")]
        public string/*IP*/ ToAddress { get; set; }

        /// <summary>
        /// type
        /// Type of the IP-binding action
        ///  regular - performs One-to-One NAT according to the rule, translates address to to-address
        ///  bypassed - performs the translation, but excludes client from login to the HotSpot
        ///  blocked - translation is not performed and packets from host are dropped
        /// </summary>
        [TikProperty("type", DefaultValue = "")]
        public string/*blocked | bypassed | regular*/ Type { get; set; }
    }
}

var profile = vResult.GetResponseFieldOrDefault("actual-profile", "(none)");

if (vResult.Words.ContainsKey("actual-profile"))
{
  // Do something
}

/interface ethernet monitor ether3 once

                      name: eth3-AP-AC-45
                    status: link-ok
          auto-negotiation: done
                      rate: 1Gbps
               full-duplex: yes
           tx-flow-control: no
           rx-flow-control: no
               advertising: 10M-half,10M-full,100M-half,100M-full,1000M-half,1000M-full
  link-partner-advertising: 10M-half,10M-full,100M-half,100M-full,1000M-half,1000M-full

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace tik4net.Objects.Interface.Ethernet
{
    /// <summary>
    /// /interface ethernet monitor: command prints out current link, rate and duplex status of an interface. 
    /// </summary>
    [TikEntity("/interface/ethernet/monitor", LoadCommand = "", LoadDefaultParameneterFormat = TikCommandParameterFormat.NameValue, IncludeDetails = false, IsReadOnly = true)]
    public class EthernetMonitor
    {
        /// <summary>
        /// name
        /// </summary>
        [TikProperty("name", IsMandatory = true, IsReadOnly = true)]
        public string Name { get; private set; }

        /// <summary>
        /// auto-negotiation
        /// Current auto negotiation status:
        ///  done - negotiation completed
        ///  incomplete - negotiation failed or not yet completed
        /// </summary>
        [TikProperty("auto-negotiation")]
        public string/*done | incomplete*/ AutoNegotiation { get; set; }

        /// <summary>
        /// default-cable-settings
        /// Default cable length setting (only applicable to NS DP83815/6 cards)
        ///  short - support short cables 
        ///  standard - support standard cables
        /// </summary>
        [TikProperty("default-cable-settings")]
        public string/*short | standard*/ DefaultCableSettings { get; set; }

        /// <summary>
        /// full-duplex: Whether transmission of data occurs in two directions simultaneously
        /// </summary>
        [TikProperty("full-duplex")]
        public bool FullDuplex { get; set; }

        /// <summary>
        /// rate: Actual data rate of the connection.
        /// </summary>
        [TikProperty("rate")]
        public string/*10Mbps | 100Mbps | 1Gbps*/ Rate { get; set; }

        /// <summary>
        /// status
        /// Current link status of an interface
        ///  link-ok - the card is connected to the network
        ///  no-link - the card is not connected to the network
        ///  unknown - the connection is not recognized (if the card does not report connection status)
        /// </summary>
        [TikProperty("status")]
        public string/*link-ok | no-link | unknown*/ Status { get; set; }

        /// <summary>
        /// tx-flow-control: Whether TX flow control is used
        /// </summary>
        [TikProperty("tx-flow-control")]
        public string TxFlowControl { get; set; }

        /// <summary>
        /// rx-flow-control: Whether RX flow control is used
        /// </summary>
        [TikProperty("rx-flow-control")]
        public string RxFlowControl { get; set; }

        /// <summary>
        /// sfp-module-present: Whether SFP module is in cage
        /// </summary>
        [TikProperty("sfp-module-present")]
        public bool SfpModulePresent { get; set; }

        /// <summary>
        /// sfp-rx-lose: 
        /// </summary>
        [TikProperty("sfp-rx-lose")]
        public bool SfpRxLose { get; set; }

        /// <summary>
        /// sfp-tx-fault: 
        /// </summary>
        [TikProperty("sfp-tx-fault")]
        public bool SfpTxFault { get; set; }

        /// <summary>
        /// sfp-connector-type: 
        /// </summary>
        [TikProperty("sfp-connector-type")]
        public string SfpConnectorType { get; set; }

        /// <summary>
        /// sfp-link-length-copper: Detected link length when copper SFP module is used
        /// </summary>
        [TikProperty("sfp-link-length-copper")]
        public string SfpLinkLengthCopper { get; set; }

        /// <summary>
        /// sfp-vendor-name: Vendor of the SFP module
        /// </summary>
        [TikProperty("sfp-vendor-name")]
        public string SfpVendorName { get; set; }

        /// <summary>
        /// sfp-vendor-part-number: SFP module part number
        /// </summary>
        [TikProperty("sfp-vendor-part-number")]
        public string SfpVendorPartNumber { get; set; }

        /// <summary>
        /// sfp-vendor-revision: SFP module revision number
        /// </summary>
        [TikProperty("sfp-vendor-revision")]
        public string SfpVendorRevision { get; set; }

        /// <summary>
        /// sfp-vendor-serial: SFP module serial number
        /// </summary>
        [TikProperty("sfp-vendor-serial")]
        public string SfpVendorSerial { get; set; }

        /// <summary>
        /// sfp-manufacturing-date: SFP module manufacturing date
        /// </summary>
        [TikProperty("sfp-manufacturing-date")]
        public string SfpManufacturingDate { get; set; }

        /// <summary>
        /// eeprom: EEPROM of an SFP module
        /// </summary>
        [TikProperty("eeprom")]
        public string Eeprom { get; set; }

        /// <summary>
        /// Gets snapshot of actual values for given <paramref name="interfaceName"/>.
        /// </summary>
        public static EthernetMonitor GetSnapshot(ITikConnection connection, string interfaceName)
        {
            return EthernetMonitorConnectionExtensions.GetEthernetMonitorSnapshot(connection, interfaceName);
        }

    }

    /// <summary>
    /// Connection extension class for <see cref="InterfaceMonitorTraffic"/>
    /// </summary>
    public static class EthernetMonitorConnectionExtensions
    {
        /// <summary>
        /// Gets snapshot of actual values for given <paramref name="interfaceName"/>.
        /// </summary>
        public static EthernetMonitor GetEthernetMonitorSnapshot(this ITikConnection connection, string interfaceName)
        {
            var result = connection.LoadSingle<EthernetMonitor>(
                connection.CreateParameter("numbers", interfaceName, TikCommandParameterFormat.NameValue),
                connection.CreateParameter("once", "", TikCommandParameterFormat.NameValue));

            return result;
        }
    }
}

/interface print detail

name="eth10-myName" default-name="ether10" type="ether" mtu=1500 
       actual-mtu=1500 l2mtu=1598 max-l2mtu=9498 mac-address=D4:CA:6D:CC:BB:AA 
       last-link-down-time=nov/30/2018 17:25:50 
       last-link-up-time=nov/30/2018 17:25:51 link-downs=1 

[TikProperty("last-link-down-time")]
public string LastLinkDownTime { get; set; }

[TikProperty("last-link-up-time")]
public string LastLinkUpTime { get; set; }

        /// <summary>
        /// Statistics - bytes
        /// </summary>
        [TikProperty("bytes", IsReadOnly = true)]
        public long Bytes { get; private set; }

        /// <summary>
        /// Statistics - packets
        /// </summary>
        [TikProperty("packets", IsReadOnly = true)]
        public long Packets { get; private set; }

Using connection As ITikConnection = ConnectionFactory.CreateConnection(TikConnectionType.Api)
	connection.Open("10.0.1.207", "admin", "12345")

    Dim smsCmd As ITikCommand = connection.CreateCommand("/tool/sms/send", 
	connection.CreateParameter("port", "lte"),
	connection.CreateParameter("phone-number", "5694341XXXX"), 
	connection.CreateParameter("message", "Test message." & dateTime.now().toString()))
	smsCmd.ExecuteNonQuery()	
End using

Using connection As ITikConnection = ConnectionFactory.CreateConnection(TikConnectionType.Api)

  connection.Open("10.0.1.207", "admin", "12345")

  Dim smsCmd As ITikCommand =
    connection.CreateCommandAndParameters(
      "/tool/sms/send",
      TikCommandParameterFormat.NameValue,
      "port", "lte",
      "phone-number", "5694341XXXX",
      "message", "Test message." & DateTime.Now.ToString())

  smsCmd.ExecuteSingleRow()

End Using

/tool sms inbox remove [find]

ITikCommand cmd = connection.CreateCommand("/tool/sms/inbox/remove");
connection.CreateParameter("numbers", "[find]");
cmd.ExecuteNonQuery();

ITikCommand cmd = connection.CreateCommand("/tool/sms/inbox/remove [find]");
cmd.ExecuteNonQuery();

using (var conn = tik4net.ConnectionFactory.OpenConnection(TikConnectionType.Api, "192.168.88.1", 8728, "admin", ""))
{
  var list =
    conn.CreateCommandAndParameters(
      "/tool/sms/inbox/print",
      TikCommandParameterFormat.NameValue,
      ".proplist", ".id"
    ).ExecuteList();

  foreach (var item in list)
  {
    conn.CreateCommandAndParameters(
      "/tool/sms/inbox/remove",
      ".id", item.Words[".id"]
    ).ExecuteNonQuery();
  }
}

void Main()
{
  using (var conn = tik4net.ConnectionFactory.OpenConnection(TikConnectionType.Api, "192.168.88.1", 8728, "admin", ""))
  {
    conn.DeleteAll<ToolSmsInbox>();
  }
}

[TikEntity("/tool/sms/inbox")]
public class ToolSmsInbox
{
  [TikProperty(".id")]
  public string Id { get; private set; }

  [TikProperty("phone")]
  public string Phone { get; private set; }

  [TikProperty("type")]
  public string Type { get; private set; }

  [TikProperty("timestamp")]
  public string Timestamp { get; private set; }

  [TikProperty("message")]
  public string Message { get; private set; }
}

What's new in 6.45.2 (2019-Jul-17 10:04):

Important note!!!
Due to removal of compatibility with old version passwords in this version, downgrading to any version prior to v6.43 (v6.42.12 and older) will clear all user passwords and allow password-less authentication. Please secure your router after downgrading.
Old API authentication method will also no longer work, see documentation for new login procedure:
https://wiki.mikrotik.com/wiki/Manual:API#Initial_login

using (var conn = ConnectionFactory.OpenConnection(TikConnectionType.Api_v2, "192.168.88.1", "admin", ""))
{
  var cmd = conn.CreateCommand("/system/identity/print");
  var result = cmd.ExecuteSingleRow();
  Console.WriteLine(result.Words["name"]);
}

Code: Select all

/interface pppoe-server remove [find user=ex]

  using (var conn = ConnectionFactory.OpenConnection(TikConnectionType.Api_v2, "192.168.88.1", 8728, "admin", ""))
  {
    var command = conn.CreateCommand("/interface/pppoe-server/print");
    command.AddParameter(".proplist", ".id", TikCommandParameterFormat.NameValue);
    command.AddParameterAndValues("user", "ex");

    var list = command.ExecuteList();
  
    foreach (var item in list)
    {
      conn.CreateCommandAndParameters(
        "/interface/pppoe-server/remove",
        ".id", item.Words[".id"]
      ).ExecuteNonQuery();
    }
  }

void Main()
{
  using (var conn = ConnectionFactory.OpenConnection(TikConnectionType.Api_v2, "192.168.88.1", 8728, "admin", ""))
  {
    var list = conn.LoadList<PppoeServer>(conn.CreateParameter("user", "ex"));
    foreach (var item in list)
    {
      conn.Delete(item);
    }
  }
}

[TikEntity("/interface/pppoe-server")]
public class PppoeServer
{
  [TikProperty(".id")]
  public string Id { get; set; }

  [TikProperty("user")]
  public string User { get;set;}
}

using (ITikConnection connection = ConnectionFactory.CreateConnection(TikConnectionType.Api_v2)) // Use TikConnectionType.Api for mikrotikversion prior v6.45
   {
      connection.Open(HOST, USER, PASS);

protected void Login_Click(object sender, EventArgs e)
    {
        try
        {
            // Using Tik4Net connecion to Login
            ITikConnection connection = ConnectionFactory.OpenConnection(TikConnectionType.Api_v2, TextBox1.Text, TextBox2.Text, TextBox3.Text);

            // Now creating command string
            ITikCommand cmd = connection.CreateCommand("/system/identity/print");

            // Execute the command and add it in a string
            string identity = cmd.ExecuteScalar();

            // Print it on Website
            //Response.Write("Identity: " + identity);
            Mess.ForeColor = System.Drawing.Color.Green;
            Mess.Text = "Identity :" + identity; 
        } catch(Exception ex )
        {
            //Response.Write("Exception : " + ex.Message);
            Mess.ForeColor = System.Drawing.Color.Red;
            Mess.Text = ex.Message;
        }

    }
}

 protected void Login_Click(object sender, EventArgs e)
    {
        try
        {
            // Using Tik4Net connecion to Login
            ITikConnection connection = ConnectionFactory.OpenConnection(TikConnectionType.Api_v2, TextBox1.Text, TextBox2.Text, TextBox3.Text);

            // Now creating command string
            ITikCommand cmd = connection.CreateCommand("/system/identity/print");

            // Execute the command and add it in a string
            string identity = cmd.ExecuteScalar();

            // Print it on Website
            //Response.Write("Identity: " + identity);
            Mess.ForeColor = System.Drawing.Color.Green;
            Mess.Text = "Identity :" + identity; 
        } catch(Exception ex )
        {
            //Response.Write("Exception : " + ex.Message);
            Mess.ForeColor = System.Drawing.Color.Red;
            Mess.Text = ex.Message;
        }

    }
}

Dim connection = ConnectionFactory.OpenConnection(TikConnectionType.Api, IP, u, p)
Dim loadCmd = connection.CreateCommandAndParameters("/interface/lte/info", "number", "0", "once", "")
Dim response = loadCmd.ExecuteList()

ITikCommand monitor = connection.CreateCommandAndParameters("/interface/ethernet/monitor", "interface", "ether3");
monitor.ExecuteAsync(re => responses.Add(re));
System.Threading.Thread.Sleep(5000);
monitor.CancelAndJoin();

monitor = connection.CreateCommandAndParameters("/interface/monitor-traffic", "interface", "ether3");

monitor.ExecuteAsync(
  re => responses.Add(re),
  e => Console.WriteLine(e.ToString()));

ITikCommand monitor = conn.CreateCommandAndParameters("/interface/ethernet/monitor", ".id", "ether3");

EthernetMonitor em = EthernetMonitor.GetSnapshot(connection, "ether3");
string linkspeed = em.Rate;