# Erste Schritte

> Tutorial: Den ersten Server mit dem OPC UA .NET SDK aufsetzen: Namespace einbinden, Server erzeugen, starten und wieder beenden.

**Beispielanwendungen:**

- Server.Temperature ([C#](https://github.com/Traeger-GmbH/opcuanet-samples/tree/master/cs/Scenarios/Server.Temperature), [VB.NET](https://github.com/Traeger-GmbH/opcuanet-samples/tree/master/vb/Scenarios/Server.Temperature)): Stellt einen Temperatur-Node bereit und ändert seinen Wert einmal je Sekunde.
- Client.Temperature ([C#](https://github.com/Traeger-GmbH/opcuanet-samples/tree/master/cs/Scenarios/Client.Temperature), [VB.NET](https://github.com/Traeger-GmbH/opcuanet-samples/tree/master/vb/Scenarios/Client.Temperature)): Verbindet sich mit einem Server und liest einmal je Sekunde den Wert eines Temperatur-Nodes.

## Voraussetzungen

- **Zielframework:** .NET oder .NET Framework ab 4.7.2, alle unterstützten unter [Zielframeworks](https://www.traeger.de/docs/development/opcua/requirements#zielframeworks)
- **NuGet-Paket:** `Opc.UaFx.Advanced` ([Downloads](https://www.traeger.de/docs/development/opcua/downloads))
- **Lizenz:** für die Evaluation nicht erforderlich. Ohne Lizenzschlüssel läuft das SDK je Anwendungsstart 30 Minuten uneingeschränkt ([Lizenz einrichten](https://www.traeger.de/docs/development/opcua/license-setup#evaluation))

## Server erzeugen

**1.** Einen Verweis auf den Namespace `Opc.UaFx.Server` (Paket `Opc.UaFx.Advanced`) hinzufügen. Die meisten weiteren Typen liegen im Namespace `Opc.UaFx`:

```csharp
using Opc.UaFx.Server;
```

```vbnet
Imports Opc.UaFx.Server
```

**2.** Eine Instanz der Klasse `OpcServer` mit der gewünschten Standard-Basis-Adresse erzeugen. Ohne Angabe verwendet der Server die Adresse `opc.tcp://localhost:4840`:

```csharp
var server = new OpcServer("opc.tcp://localhost:4840/");
```

```vbnet
Dim server = New OpcServer("opc.tcp://localhost:4840/")
```

## Server starten

**3.** Server starten und Clients bedienen:

```csharp
server.Start();
```

```vbnet
server.Start()
```

**4.** Ihr Code, der die Anfragen der Clients bearbeitet:

```csharp
// Your code to process client requests.
```

```vbnet
'Your code to process client requests.
```

## Server beenden

**5.** Vor dem Beenden der Anwendung alle Sitzungen beenden und den Server herunterfahren:

```csharp
server.Stop();
```

```vbnet
server.Stop()
```

## Server im using-Block

**6.** In einem using-Block sieht das so aus:

```csharp
using (var server = new OpcServer("opc.tcp://localhost:4840/")) {
    server.Start();
    // Your code to process client requests.
}
```

```vbnet
Using server As new OpcServer("opc.tcp://localhost:4840/")
    server.Start()
    'Your code to process client requests.
End Using
```

## Server in Tests

Ein Server mit Test-Nodes lässt sich im selben Prozess wie ein Client starten, um Client-Logik ohne Anlage automatisiert zu prüfen. Wie das geht, zeigt die Seite [Clients testen](https://www.traeger.de/docs/development/opcua/client/testing).

## Vollständiges Beispiel

Ein eigener Server, der einen Temperatur-Node bereitstellt, dessen Wert
zyklisch aktualisiert und Subscriptions von Clients bedient:

```csharp
namespace Server
{
    using System.Threading;

    using Opc.UaFx;
    using Opc.UaFx.Server;

    /// <summary>
    /// This sample demonstrates how to setup an OPC UA server that provides a temperature node and
    /// updates its value once per second.
    /// </summary>
    public class Program
    {
        public static void Main()
        {
            var temperatureNode = new OpcDataVariableNode<double>("Temperature", 100.0);

            using (var server = new OpcServer("opc.tcp://localhost:4840/", temperatureNode)) {
                server.Start();

                while (true) {
                    if (temperatureNode.Value == 110)
                        temperatureNode.Value = 100;
                    else
                        temperatureNode.Value++;

                    temperatureNode.ApplyChanges(server.SystemContext);
                    Thread.Sleep(1000);
                }
            }
        }
    }
}

```

```vbnet
Imports System.Threading

Imports Opc.UaFx
Imports Opc.UaFx.Server

Namespace Server
    ''' <summary>
    ''' This sample demonstrates how to setup an OPC UA server that provides a temperature node and
    ''' updates its value once per second.
    ''' </summary>
    Public Class Program
        Public Shared Sub Main()
            Dim temperatureNode = New OpcDataVariableNode(Of Double)("Temperature", 100.0)

            Using server = New OpcServer("opc.tcp://localhost:4840/", temperatureNode)
                server.Start()

                While True
                    If (temperatureNode.Value = 110) Then
                        temperatureNode.Value = 100
                    Else
                        temperatureNode.Value += 1
                    End If

                    temperatureNode.ApplyChanges(server.SystemContext)
                    Thread.Sleep(1000)
                End While
            End Using
        End Sub
    End Class
End Namespace

```

Der Server stellt den Node `Temperature` bereit und erhöht dessen Wert einmal je Sekunde von 100 bis 110, danach beginnt er wieder bei 100. Zur Kontrolle eignet sich der Client aus dem [vollständigen Beispiel](https://www.traeger.de/docs/development/opcua/client/getting-started#vollstandiges-beispiel) der Client-Entwicklung: Er liest den Wert einmal je Sekunde und gibt ihn aus.

## Nächste Schritte

- [Nodes verwalten](https://www.traeger.de/docs/development/opcua/server/node-management): Nodes im Adressraum des Servers erstellen, ihre Sichtbarkeit steuern und sie zur Laufzeit aktualisieren.

- [Werte lesen und schreiben](https://www.traeger.de/docs/development/opcua/server/read-write-values): Werte von Nodes im Server bereitstellen und Lese- sowie Schreibzugriffe von Clients behandeln.

- [Node-Modelle](https://www.traeger.de/docs/development/opcua/server/node-models): Mit OpcNodeModel festlegen, welche Kind-Nodes beim Erzeugen eines typisierten Nodes entstehen, und Startwerte aus der Typdefinition übernehmen.

- [Server absichern](https://www.traeger.de/docs/development/opcua/security/server): Den Server absichern: Endpunkte, Zertifikate, Benutzer, Rollen und Zugriffskontrolllisten, Audit-Ereignisse und eine Checkliste für den Betrieb.