### Validate NTP Synchronization Status with GuerrillaNtp

Source: https://context7.com/robertvazan/guerrillantp/llms.txt

This example illustrates how to check if the time obtained via NTP is synchronized and reliable using the 'Synchronized' property of NtpClock. If synchronized, it prints details like network time, correction offset, and round-trip time, along with response details such as stratum, root delay, and root dispersion. If not synchronized, it attempts to identify the reason for failure.

```csharp
using GuerrillaNtp;
using System;

var client = new NtpClient();

try
{
    NtpClock clock = client.Query();

    // Check if time can be trusted
    if (clock.Synchronized)
    {
        Console.WriteLine("✓ Time is synchronized");
        Console.WriteLine($"  Network time: {clock.UtcNow.UtcDateTime}");
        Console.WriteLine($"  Correction: {clock.CorrectionOffset.TotalMilliseconds}ms");
        Console.WriteLine($"  Round-trip: {clock.RoundTripTime.TotalMilliseconds}ms");

        // Inspect response for details
        var response = clock.Response;
        Console.WriteLine($"  Stratum: {response.Stratum}");
        Console.WriteLine($"  Root delay: {response.RootDelay.TotalMilliseconds}ms");
        Console.WriteLine($"  Root dispersion: {response.RootDispersion.TotalMilliseconds}ms");
    }
    else
    {
        Console.WriteLine("✗ Time is NOT synchronized");

        // Check why synchronization failed
        if (clock.Response.LeapIndicator == NtpLeapIndicator.AlarmCondition)
            Console.WriteLine("  Reason: Server clock alarm");
        if (clock.Response.Stratum == 0)
            Console.WriteLine("  Reason: Kiss-o'-Death packet");
        if (clock.Response.RootDelay.TotalSeconds > 1)
            Console.WriteLine("  Reason: High root delay");
        if (clock.Response.RootDispersion.TotalSeconds > 1)
            Console.WriteLine("  Reason: High root dispersion");
        if (clock.RoundTripTime.TotalSeconds > 1)
            Console.WriteLine("  Reason: High round-trip time");
    }
}
catch (Exception ex)
{
    Console.WriteLine($"Query failed: {ex.Message}");
}
```

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

### Create Custom NTP Client with Specific Settings (C#)

Source: https://context7.com/robertvazan/guerrillantp/llms.txt

Demonstrates how to create custom NtpClient instances with various configurations, including different hostnames, IP addresses, ports, and timeouts. Allows for precise control over NTP server selection and query behavior.

```csharp
using GuerrillaNtp;
using System;
using System.Net;

// Client with custom host
var client1 = new NtpClient("time.google.com");

// Client with custom host and timeout
var client2 = new NtpClient(
    host: "time.windows.com",
    timeout: TimeSpan.FromSeconds(2),
    port: 123
);

// Client with IP address
var client3 = new NtpClient(
    ip: IPAddress.Parse("216.239.35.0"),
    timeout: TimeSpan.FromMilliseconds(1500)
);

// Client with custom endpoint
var endpoint = new DnsEndPoint("time.nist.gov", 123);
var client4 = new NtpClient(endpoint, TimeSpan.FromSeconds(3));

try
{
    NtpClock clock = client1.Query();
    Console.WriteLine($"Time from {client1}: {clock.UtcNow.UtcDateTime}");

    // Access last query result
    if (client1.Last != null)
    {
        Console.WriteLine($"Last query offset: {client1.Last.CorrectionOffset}");
    }
}
catch (Exception ex)
{
    Console.WriteLine($"Error: {ex.Message}");
}
```

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

### Create Custom NTP Client

Source: https://context7.com/robertvazan/guerrillantp/llms.txt

Configure and use a custom NTP client with specific server endpoints, ports, and timeouts. This allows for more control over the NTP query process.

```APIDOC
## Create Custom NTP Client

### Description
Configure and use a custom NTP client with specific server endpoints, ports, and timeouts. This allows for more control over the NTP query process.

### Method
GET (simulated, uses library's custom client)

### Endpoint
N/A (library method call)

### Parameters
- **host** (string) - Optional - The hostname or IP address of the NTP server.
- **timeout** (TimeSpan) - Optional - The timeout for the NTP query.
- **port** (int) - Optional - The UDP port for the NTP server (default is 123).
- **ip** (IPAddress) - Optional - The IP address of the NTP server.
- **endpoint** (DnsEndPoint) - Optional - A custom endpoint including hostname and port.

### Request Example
```csharp
using GuerrillaNtp;
using System;
using System.Net;

// Client with custom host
var client1 = new NtpClient("time.google.com");

// Client with custom host and timeout
var client2 = new NtpClient(
    host: "time.windows.com",
    timeout: TimeSpan.FromSeconds(2),
    port: 123
);

// Client with IP address
var client3 = new NtpClient(
    ip: IPAddress.Parse("216.239.35.0"),
    timeout: TimeSpan.FromMilliseconds(1500)
);

// Client with custom endpoint
var endpoint = new DnsEndPoint("time.nist.gov", 123);
var client4 = new NtpClient(endpoint, TimeSpan.FromSeconds(3));

try
{
    NtpClock clock = client1.Query();
    Console.WriteLine($"Time from {client1}: {clock.UtcNow.UtcDateTime}");

    if (client1.Last != null)
    {
        Console.WriteLine($"Last query offset: {client1.Last.CorrectionOffset}");
    }
}
catch (Exception ex)
{
    Console.WriteLine($"Error: {ex.Message}");
}
```

### Response
#### Success Response (200)
- **NtpClock** (object) - An object containing synchronized time and related metadata from the custom configured server.
    - **UtcNow** (DateTimeOffset) - The current UTC time obtained from the NTP server.
    - **Last** (NtpClock) - The result of the last query made by this client instance (if available).

#### Response Example
```json
{
  "UtcNow": "2023-10-27T10:40:05.5555555Z",
  "Last": {
    "UtcNow": "2023-10-27T10:40:05.5555555Z",
    "Now": "2023-10-27T13:40:05.5555555+03:00",
    "Synchronized": true,
    "CorrectionOffset": "00:00:00.0087654",
    "RoundTripTime": "00:00:00.0301234",
    "Response": {
      "Stratum": 1,
      "LeapIndicator": 0,
      "Precision": -7,
      "PollInterval": 5,
      "RootDelay": "00:00:00.0050000",
      "RootDispersion": "00:00:00.0020000",
      "ReferenceClock": "LOCL",
      "ReferenceTime": "2023-10-27T10:40:00.0000000Z",
      "OriginateTimestamp": "2023-10-27T10:40:05.0000000Z",
      "ReceiveTimestamp": "2023-10-27T10:40:05.0050000Z",
      "TransmitTimestamp": "2023-10-27T10:40:05.0100000Z"
    }
  }
}
```
```

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

### Query NTP Server Synchronously with Default Configuration (C#)

Source: https://context7.com/robertvazan/guerrillantp/llms.txt

Queries the default NTP server (pool.ntp.org) to retrieve network-synchronized time and its offset from the local system time. Handles potential NTP or network exceptions.

```csharp
using GuerrillaNtp;
using System;

// Query using the default client (pool.ntp.org)
try
{
    NtpClock clock = NtpClient.Default.Query();

    // Get network-synchronized time
    DateTimeOffset networkTime = clock.UtcNow;
    Console.WriteLine($"Network time (UTC): {networkTime.UtcDateTime}");
    Console.WriteLine($"Network time (Local): {clock.Now.LocalDateTime}");

    // Check if time is synchronized
    if (clock.Synchronized)
    {
        Console.WriteLine($"Time offset: {clock.CorrectionOffset.TotalMilliseconds}ms");
        Console.WriteLine($"Round-trip time: {clock.RoundTripTime.TotalMilliseconds}ms");
    }
    else
    {
        Console.WriteLine("Warning: Server is not synchronized");
    }
}
catch (NtpException ex)
{
    Console.WriteLine($"NTP error: {ex.Message}");
}
catch (System.Net.Sockets.SocketException ex)
{
    Console.WriteLine($"Network error: {ex.Message}");
}
```

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

### Query NTP Server with Default Configuration

Source: https://context7.com/robertvazan/guerrillantp/llms.txt

Query the default NTP server (pool.ntp.org) and retrieve network-synchronized time using the default client configuration. This method is synchronous.

```APIDOC
## Query NTP Server with Default Configuration

### Description
Query the default NTP server (pool.ntp.org) and retrieve network-synchronized time using the default client configuration. This method is synchronous.

### Method
GET (simulated, uses library's default client)

### Endpoint
N/A (library method call)

### Parameters
None

### Request Example
```csharp
using GuerrillaNtp;
using System;

try
{
    NtpClock clock = NtpClient.Default.Query();

    DateTimeOffset networkTime = clock.UtcNow;
    Console.WriteLine($"Network time (UTC): {networkTime.UtcDateTime}");
    Console.WriteLine($"Network time (Local): {clock.Now.LocalDateTime}");

    if (clock.Synchronized)
    {
        Console.WriteLine($"Time offset: {clock.CorrectionOffset.TotalMilliseconds}ms");
        Console.WriteLine($"Round-trip time: {clock.RoundTripTime.TotalMilliseconds}ms");
    }
    else
    {
        Console.WriteLine("Warning: Server is not synchronized");
    }
}
catch (NtpException ex)
{
    Console.WriteLine($"NTP error: {ex.Message}");
}
catch (System.Net.Sockets.SocketException ex)
{
    Console.WriteLine($"Network error: {ex.Message}");
}
```

### Response
#### Success Response (200)
- **NtpClock** (object) - An object containing synchronized time and related metadata.
    - **UtcNow** (DateTimeOffset) - The current UTC time obtained from the NTP server.
    - **Now** (DateTimeOffset) - The current local time adjusted by the synchronization offset.
    - **Synchronized** (bool) - Indicates if the time was successfully synchronized.
    - **CorrectionOffset** (TimeSpan) - The calculated offset between the local system clock and the NTP server.
    - **RoundTripTime** (TimeSpan) - The time taken for the NTP request and response.
    - **Response** (NtpResponse) - Detailed response information from the NTP server.

#### Response Example
```json
{
  "UtcNow": "2023-10-27T10:30:00.1234567Z",
  "Now": "2023-10-27T13:30:00.1234567+03:00",
  "Synchronized": true,
  "CorrectionOffset": "00:00:00.0051234",
  "RoundTripTime": "00:00:00.0258765",
  "Response": {
    "Stratum": 1,
    "LeapIndicator": 0,
    "Precision": -6,
    "PollInterval": 4,
    "RootDelay": "00:00:00.0100000",
    "RootDispersion": "00:00:00.0050000",
    "ReferenceClock": "12345",
    "ReferenceTime": "2023-10-27T10:29:55.0000000Z",
    "OriginateTimestamp": "2023-10-27T10:30:00.0000000Z",
    "ReceiveTimestamp": "2023-10-27T10:30:00.0100000Z",
    "TransmitTimestamp": "2023-10-27T10:30:00.0150000Z"
  }
}
```
```

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

### Low-Level NTP Packet Manipulation with GuerrillaNtp

Source: https://context7.com/robertvazan/guerrillantp/llms.txt

This C# code snippet demonstrates low-level manipulation of NTP packets using the GuerrillaNtp library. It covers creating a request packet, serializing it into bytes, and then parsing a response from bytes. It includes validation of the received packet, conversion to an NtpResponse object, checking if the response matches the request, and creating an NtpClock from the response. Error handling for invalid packets is also shown.

```csharp
using GuerrillaNtp;
using System;

// Create a request packet
var request = new NtpRequest
{
    TransmitTimestamp = DateTime.UtcNow
};

// Convert to packet and serialize
NtpPacket requestPacket = request.ToPacket();
byte[] requestBytes = requestPacket.ToBytes();
Console.WriteLine($"Request packet size: {requestBytes.Length} bytes");

// Parse response from bytes
byte[] responseBytes = new byte[48]; // Would come from socket receive
// ... (receive from network) ...

try
{
    NtpPacket responsePacket = NtpPacket.FromBytes(responseBytes, responseBytes.Length);

    // Validate packet
    responsePacket.Validate();

    // Convert to response
    NtpResponse response = NtpResponse.FromPacket(responsePacket);

    // Check if response matches request
    if (response.Matches(request))
    {
        Console.WriteLine("✓ Response matches request");
        Console.WriteLine($"Origin timestamp: {response.OriginTimestamp}");
        Console.WriteLine($"Receive timestamp: {response.ReceiveTimestamp}");
        Console.WriteLine($"Transmit timestamp: {response.TransmitTimestamp}");
        Console.WriteLine($"Destination timestamp: {response.DestinationTimestamp}");

        // Create clock from response
        var clock = new NtpClock(response);
        Console.WriteLine($"Network time: {clock.UtcNow.UtcDateTime}");
    }
    else
    {
        Console.WriteLine("✗ Response does not match request");
    }
}
catch (NtpException ex)
{
    Console.WriteLine($"Invalid packet: {ex.Message}");
}
```

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

### Implement Persistent Time Service with C# NTP Client

Source: https://context7.com/robertvazan/guerrillantp/llms.txt

Creates a background service using GuerrillaNtp to maintain synchronized time throughout an application's lifecycle. It uses a timer to periodically query NTP servers and provides properties to access the synchronized time. The service falls back to the local clock if network synchronization fails. This implementation is suitable for applications requiring continuous time accuracy.

```csharp
using GuerrillaNtp;
using System;
using System.Threading;
using System.Threading.Tasks;

public class TimeService
{
    private readonly NtpClient _client;
    private readonly Timer _timer;
    private readonly TimeSpan _updateInterval = TimeSpan.FromMinutes(15);

    public TimeService(string ntpServer = null)
    {
        _client = ntpServer != null
            ? new NtpClient(ntpServer)
            : NtpClient.Default;

        _timer = new Timer(
            callback: async _ => await UpdateTimeAsync(),
            state: null,
            dueTime: TimeSpan.Zero,
            period: _updateInterval
        );
    }

    public DateTimeOffset Now => (_client.Last ?? NtpClock.LocalFallback).Now;
    public DateTimeOffset UtcNow => (_client.Last ?? NtpClock.LocalFallback).UtcNow;
    public bool IsSynchronized => _client.Last?.Synchronized ?? false;

    private async Task UpdateTimeAsync()
    {
        try
        {
            await _client.QueryAsync();
            Console.WriteLine($"Time synchronized: {UtcNow}");
        }
        catch (Exception ex)
        {
            Console.WriteLine($"Time sync failed: {ex.Message}");
        }
    }

    public async Task<bool> SynchronizeAsync()
    {
        try
        {
            await _client.QueryAsync();
            return IsSynchronized;
        }
        catch
        {
            return false;
        }
    }

    public void Dispose()
    {
        _timer?.Dispose();
    }
}

// Usage
var timeService = new TimeService("time.google.com");

// Wait for initial sync
await timeService.SynchronizeAsync();

// Use synchronized time throughout application
Console.WriteLine($"Network time: {timeService.UtcNow}");
Console.WriteLine($"Synchronized: {timeService.IsSynchronized}");

// Service will auto-update every 15 minutes
await Task.Delay(TimeSpan.FromMinutes(20));
Console.WriteLine($"Updated time: {timeService.UtcNow}");

timeService.Dispose();

```

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

### Calculate and Apply Time Correction Offsets with NtpClock

Source: https://context7.com/robertvazan/guerrillantp/llms.txt

This snippet demonstrates how to use NtpClock from the GuerrillaNtp library to query the network time, retrieve the correction offset, and manually calculate the corrected local time. It also shows how to access the built-in properties for corrected time and the last known synchronized clock, including a fallback to local time in case of errors.

```csharp
using GuerrillaNtp;
using System;

var client = new NtpClient();

try
{
    NtpClock clock = client.Query();

    // Get correction offset
    TimeSpan offset = clock.CorrectionOffset;
    Console.WriteLine($"Clock offset: {offset.TotalMilliseconds}ms");

    // Calculate corrected time manually
    DateTime localTime = DateTime.UtcNow;
    DateTime correctedTime = localTime + offset;
    Console.WriteLine($"Local time: {localTime}");
    Console.WriteLine($"Corrected time: {correctedTime}");

    // Or use the built-in properties
    Console.WriteLine($"Network time (NtpClock): {clock.UtcNow.UtcDateTime}");

    // Access stored result
    NtpClock lastClock = client.Last ?? NtpClock.LocalFallback;
    Console.WriteLine($"Using stored clock: {lastClock.UtcNow.UtcDateTime}");
    Console.WriteLine($"Is synchronized: {lastClock.Synchronized}");
}
catch (Exception ex)
{
    Console.WriteLine($"Error: {ex.Message}");

    // Fallback to local time
    NtpClock fallback = NtpClock.LocalFallback;
    Console.WriteLine($"Using fallback: {fallback.UtcNow.UtcDateTime}");
}
```

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

### Handle Leap Seconds with C# NTP Client

Source: https://context7.com/robertvazan/guerrillantp/llms.txt

Detects and responds to leap second warnings from NTP servers using the GuerrillaNtp library. It checks the leap indicator in the NTP response and prints messages indicating whether a leap second is scheduled, deleted, or if the server is unsynchronized. This requires the GuerrillaNtp NuGet package.

```csharp
using GuerrillaNtp;
using System;

var client = new NtpClient();

try
{
    NtpClock clock = client.Query();
    NtpResponse response = clock.Response;

    // Check leap indicator
    switch (response.LeapIndicator)
    {
        case NtpLeapIndicator.NoWarning:
            Console.WriteLine("No leap second scheduled");
            break;

        case NtpLeapIndicator.LastMinuteHas61Seconds:
            Console.WriteLine("WARNING: Leap second insertion at end of day");
            Console.WriteLine("Last minute of today will have 61 seconds");
            break;

        case NtpLeapIndicator.LastMinuteHas59Seconds:
            Console.WriteLine("WARNING: Leap second deletion at end of day");
            Console.WriteLine("Last minute of today will have 59 seconds");
            break;

        case NtpLeapIndicator.AlarmCondition:
            Console.WriteLine("ALARM: Server clock is unsynchronized");
            Console.WriteLine("Time reported is unreliable");
            break;
    }

    if (clock.Synchronized)
    {
        Console.WriteLine($"Current network time: {clock.UtcNow.UtcDateTime}");
    }
}
catch (Exception ex)
{
    Console.WriteLine($"Error: {ex.Message}");
}
```

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

### Query NTP Server Asynchronously

Source: https://context7.com/robertvazan/guerrillantp/llms.txt

Perform non-blocking asynchronous NTP queries with cancellation support. This is useful for applications that need to remain responsive during network operations.

```APIDOC
## Query NTP Server Asynchronously

### Description
Perform non-blocking asynchronous NTP queries with cancellation support. This is useful for applications that need to remain responsive during network operations.

### Method
GET (simulated, uses library's default client asynchronously)

### Endpoint
N/A (library method call)

### Parameters
- **cancellationToken** (CancellationToken) - Required - A token to signal cancellation of the asynchronous operation.

### Request Example
```csharp
using GuerrillaNtp;
using System;
using System.Threading;
using System.Threading.Tasks;

async Task QueryNtpAsync()
{
    var cts = new CancellationTokenSource(TimeSpan.FromSeconds(5));

    try
    {
        NtpClock clock = await NtpClient.Default.QueryAsync(cts.Token);

        Console.WriteLine($"Network time: {clock.UtcNow.UtcDateTime}");
        Console.WriteLine($"Synchronized: {clock.Synchronized}");

        NtpResponse response = clock.Response;
        Console.WriteLine($"Server stratum: {response.Stratum}");
        Console.WriteLine($"Leap indicator: {response.LeapIndicator}");
        Console.WriteLine($"Server precision: 2^{response.Precision} seconds");
        Console.WriteLine($"Poll interval: 2^{response.PollInterval} seconds");
    }
    catch (OperationCanceledException)
    {
        Console.WriteLine("Query cancelled");
    }
    catch (Exception ex)
    {
        Console.WriteLine($"Error: {ex.Message}");
    }
}

await QueryNtpAsync();
```

### Response
#### Success Response (200)
- **NtpClock** (object) - An object containing synchronized time and related metadata.
    - **UtcNow** (DateTimeOffset) - The current UTC time obtained from the NTP server.
    - **Synchronized** (bool) - Indicates if the time was successfully synchronized.
    - **Response** (NtpResponse) - Detailed response information from the NTP server.
        - **Stratum** (int) - The stratum level of the NTP server.
        - **LeapIndicator** (int) - The leap indicator value from the NTP packet.
        - **Precision** (int) - The precision of the clock as a power of two.
        - **PollInterval** (int) - The maximum interval between successive pollings, as a power of two.

#### Response Example
```json
{
  "UtcNow": "2023-10-27T10:35:15.9876543Z",
  "Synchronized": true,
  "Response": {
    "Stratum": 2,
    "LeapIndicator": 0,
    "Precision": -5,
    "PollInterval": 6,
    "RootDelay": "00:00:00.0200000",
    "RootDispersion": "00:00:00.0080000",
    "ReferenceClock": "GPS",
    "ReferenceTime": "2023-10-27T10:35:10.0000000Z",
    "OriginateTimestamp": "2023-10-27T10:35:15.0000000Z",
    "ReceiveTimestamp": "2023-10-27T10:35:15.0100000Z",
    "TransmitTimestamp": "2023-10-27T10:35:15.0150000Z"
  }
}
```
```

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

### Query NTP Server Asynchronously with Cancellation (C#)

Source: https://context7.com/robertvazan/guerrillantp/llms.txt

Performs a non-blocking asynchronous NTP query with a configurable timeout using a CancellationTokenSource. Retrieves synchronized time and response details like stratum and leap indicator. Catches operation cancellation and general exceptions.

```csharp
using GuerrillaNtp;
using System;
using System.Threading;
using System.Threading.Tasks;

async Task QueryNtpAsync()
{
    var cts = new CancellationTokenSource(TimeSpan.FromSeconds(5));

    try
    {
        NtpClock clock = await NtpClient.Default.QueryAsync(cts.Token);

        Console.WriteLine($"Network time: {clock.UtcNow.UtcDateTime}");
        Console.WriteLine($"Synchronized: {clock.Synchronized}");

        // Access response details
        NtpResponse response = clock.Response;
        Console.WriteLine($"Server stratum: {response.Stratum}");
        Console.WriteLine($"Leap indicator: {response.LeapIndicator}");
        Console.WriteLine($"Server precision: 2^{response.Precision} seconds");
        Console.WriteLine($"Poll interval: 2^{response.PollInterval} seconds");
    }
    catch (OperationCanceledException)
    {
        Console.WriteLine("Query cancelled");
    }
    catch (Exception ex)
    {
        Console.WriteLine($"Error: {ex.Message}");
    }
}

await QueryNtpAsync();
```

=== COMPLETE CONTENT === This response contains all available snippets from this library. No additional content exists. Do not make further requests.