/// <summary>

/// Provides a simple way to create and manage the contents of connection strings used by

/// the <see cref="NpgsqlConnection"/> class.

/// </summary>

public sealed class NpgsqlConnectionStringBuilder : DbConnectionStringBuilder, IDictionary<string, object?>

{

#region Fields

/// <summary>

/// Makes all valid keywords for a property to that property (e.g. User Name -> Username, UserId -> Username...)

/// </summary>

static readonly Dictionary<string, PropertyInfo> PropertiesByKeyword;

/// <summary>

/// Maps CLR property names (e.g. BufferSize) to their canonical keyword name, which is the

/// property's [DisplayName] (e.g. Buffer Size)

/// </summary>

static readonly Dictionary<string, string> PropertyNameToCanonicalKeyword;

/// <summary>

/// Maps each property to its [DefaultValue]

/// </summary>

static readonly Dictionary<PropertyInfo, object?> PropertyDefaults;

/// <summary>

/// Cached DataSource value to reduce allocations on NpgsqlConnection.DataSource.get

/// </summary>

string? _dataSourceCached;

internal string DataSourceCached

=> _dataSourceCached ??= _host is null

? string.Empty

: Path.IsPathRooted(_host)

? Path.Combine(_host, $".s.PGSQL.{_port}")

: $"tcp://{_host}:{_port}";

#endregion

#region Constructors

/// <summary>

/// Initializes a new instance of the NpgsqlConnectionStringBuilder class.

/// </summary>

public NpgsqlConnectionStringBuilder() { Init(); }

/// <summary>

/// Initializes a new instance of the NpgsqlConnectionStringBuilder class, optionally using ODBC rules for quoting values.

/// </summary>

/// <param name="useOdbcRules">true to use {} to delimit fields; false to use quotation marks.</param>

public NpgsqlConnectionStringBuilder(bool useOdbcRules) : base(useOdbcRules) { Init(); }

/// <summary>

/// Initializes a new instance of the NpgsqlConnectionStringBuilder class and sets its <see cref="DbConnectionStringBuilder.ConnectionString"/>.

/// </summary>

public NpgsqlConnectionStringBuilder(string? connectionString)

{

Init();

ConnectionString = connectionString;

}

void Init()

{

// Set the strongly-typed properties to their default values

foreach (var kv in PropertyDefaults)

kv.Key.SetValue(this, kv.Value);

// Setting the strongly-typed properties here also set the string-based properties in the base class.

// Clear them (default settings = empty connection string)

base.Clear();

}

#endregion

#region Static initialization

static NpgsqlConnectionStringBuilder()

{

var properties = typeof(NpgsqlConnectionStringBuilder)

.GetProperties(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic)

.Where(p => p.GetCustomAttribute<NpgsqlConnectionStringPropertyAttribute>() != null)

.ToArray();

Debug.Assert(properties.All(p => p.CanRead && p.CanWrite));

Debug.Assert(properties.All(p => p.GetCustomAttribute<DisplayNameAttribute>() != null));

PropertiesByKeyword = (

from p in properties

let displayName = p.GetCustomAttribute<DisplayNameAttribute>()!.DisplayName.ToUpperInvariant()

let propertyName = p.Name.ToUpperInvariant()

from k in new[] { displayName }

.Concat(propertyName != displayName ? new[] { propertyName } : EmptyStringArray )

.Concat(p.GetCustomAttribute<NpgsqlConnectionStringPropertyAttribute>()!.Synonyms

.Select(a => a.ToUpperInvariant())

)

.Select(k => new { Property = p, Keyword = k })

select k

).ToDictionary(t => t.Keyword, t => t.Property);

PropertyNameToCanonicalKeyword = properties.ToDictionary(

p => p.Name,

p => p.GetCustomAttribute<DisplayNameAttribute>()!.DisplayName

);

PropertyDefaults = properties

.Where(p => p.GetCustomAttribute<ObsoleteAttribute>() == null)

.ToDictionary(

p => p,

p => p.GetCustomAttribute<DefaultValueAttribute>() != null

? p.GetCustomAttribute<DefaultValueAttribute>()!.Value

: (p.PropertyType.GetTypeInfo().IsValueType ? Activator.CreateInstance(p.PropertyType) : null)

);

}

#endregion

#region Non-static property handling

/// <summary>

/// Gets or sets the value associated with the specified key.

/// </summary>

/// <param name="keyword">The key of the item to get or set.</param>

/// <returns>The value associated with the specified key.</returns>

[AllowNull]

public override object this[string keyword]

{

get

{

if (!TryGetValue(keyword, out var value))

throw new ArgumentException("Keyword not supported: " + keyword, nameof(keyword));

return value;

}

set

{

if (value is null)

{

Remove(keyword);

return;

}

var p = GetProperty(keyword);

try

{

var convertedValue = p.PropertyType.GetTypeInfo().IsEnum && value is string str

? Enum.Parse(p.PropertyType, str)

: Convert.ChangeType(value, p.PropertyType);

p.SetValue(this, convertedValue);

}

catch (Exception e)

{

throw new ArgumentException("Couldn't set " + keyword, keyword, e);

}

}

}

object? IDictionary<string, object?>.this[string keyword]

{

get => this[keyword];

set => this[keyword] = value!;

}

/// <summary>

/// Adds an item to the <see cref="NpgsqlConnectionStringBuilder"/>.

/// </summary>

/// <param name="item">The key-value pair to be added.</param>

public void Add(KeyValuePair<string, object?> item)

=> this[item.Key] = item.Value!;

void IDictionary<string, object?>.Add(string keyword, object? value)

=> this[keyword] = value;

/// <summary>

/// Removes the entry with the specified key from the DbConnectionStringBuilder instance.

/// </summary>

/// <param name="keyword">The key of the key/value pair to be removed from the connection string in this DbConnectionStringBuilder.</param>

/// <returns><b>true</b> if the key existed within the connection string and was removed; <b>false</b> if the key did not exist.</returns>

public override bool Remove(string keyword)

{

var p = GetProperty(keyword);

var canonicalName = PropertyNameToCanonicalKeyword[p.Name];

var removed = base.ContainsKey(canonicalName);

// Note that string property setters call SetValue, which itself calls base.Remove().

p.SetValue(this, PropertyDefaults[p]);

base.Remove(canonicalName);

return removed;

}

/// <summary>

/// Removes the entry from the DbConnectionStringBuilder instance.

/// </summary>

/// <param name="item">The key/value pair to be removed from the connection string in this DbConnectionStringBuilder.</param>

/// <returns><b>true</b> if the key existed within the connection string and was removed; <b>false</b> if the key did not exist.</returns>

public bool Remove(KeyValuePair<string, object?> item)

=> Remove(item.Key);

/// <summary>

/// Clears the contents of the <see cref="NpgsqlConnectionStringBuilder"/> instance.

/// </summary>

public override void Clear()

{

Debug.Assert(Keys != null);

foreach (var k in Keys.ToArray()) {

Remove(k);

}

}

/// <summary>

/// Determines whether the <see cref="NpgsqlConnectionStringBuilder"/> contains a specific key.

/// </summary>

/// <param name="keyword">The key to locate in the <see cref="NpgsqlConnectionStringBuilder"/>.</param>

/// <returns><b>true</b> if the <see cref="NpgsqlConnectionStringBuilder"/> contains an entry with the specified key; otherwise <b>false</b>.</returns>

public override bool ContainsKey(string keyword)

=> keyword is null

? throw new ArgumentNullException(nameof(keyword))

: PropertiesByKeyword.ContainsKey(keyword.ToUpperInvariant());

/// <summary>

/// Determines whether the <see cref="NpgsqlConnectionStringBuilder"/> contains a specific key-value pair.

/// </summary>

/// <param name="item">The item to locate in the <see cref="NpgsqlConnectionStringBuilder"/>.</param>

/// <returns><b>true</b> if the <see cref="NpgsqlConnectionStringBuilder"/> contains the entry; otherwise <b>false</b>.</returns>

public bool Contains(KeyValuePair<string, object?> item)

=> TryGetValue(item.Key, out var value) &&

((value == null && item.Value == null) || (value != null && value.Equals(item.Value)));

PropertyInfo GetProperty(string keyword)

=> PropertiesByKeyword.TryGetValue(keyword.ToUpperInvariant(), out var p)

? p

: throw new ArgumentException("Keyword not supported: " + keyword, nameof(keyword));

/// <summary>

/// Retrieves a value corresponding to the supplied key from this <see cref="NpgsqlConnectionStringBuilder"/>.

/// </summary>

/// <param name="keyword">The key of the item to retrieve.</param>

/// <param name="value">The value corresponding to the key.</param>

/// <returns><b>true</b> if keyword was found within the connection string, <b>false</b> otherwise.</returns>

public override bool TryGetValue(string keyword, [NotNullWhen(true)] out object? value)

{

if (keyword == null)

throw new ArgumentNullException(nameof(keyword));

if (!PropertiesByKeyword.ContainsKey(keyword.ToUpperInvariant()))

{

value = null;

return false;

}

value = GetProperty(keyword).GetValue(this) ?? "";

return true;

}

void SetValue(string propertyName, object? value)

{

var canonicalKeyword = PropertyNameToCanonicalKeyword[propertyName];

if (value == null)

base.Remove(canonicalKeyword);

else

base[canonicalKeyword] = value;

}

#endregion

#region Properties - Connection

/// <summary>

/// The hostname or IP address of the PostgreSQL server to connect to.

/// </summary>

[Category("Connection")]

[Description("The hostname or IP address of the PostgreSQL server to connect to.")]

[DisplayName("Host")]

[NpgsqlConnectionStringProperty("Server")]

public string? Host

{

get => _host;

set

{

_host = value;

SetValue(nameof(Host), value);

_dataSourceCached = null;

}

}

string? _host;

/// <summary>

/// The TCP/IP port of the PostgreSQL server.

/// </summary>

[Category("Connection")]

[Description("The TCP port of the PostgreSQL server.")]

[DisplayName("Port")]

[NpgsqlConnectionStringProperty]

[DefaultValue(NpgsqlConnection.DefaultPort)]

public int Port

{

get => _port;

set

{

if (value <= 0)

throw new ArgumentOutOfRangeException(nameof(value), value, "Invalid port: " + value);

_port = value;

SetValue(nameof(Port), value);

_dataSourceCached = null;

}

}

int _port;

///<summary>

/// The PostgreSQL database to connect to.

/// </summary>

[Category("Connection")]

[Description("The PostgreSQL database to connect to.")]

[DisplayName("Database")]

[NpgsqlConnectionStringProperty("DB")]

public string? Database

{

get => _database;

set

{

_database = value;

SetValue(nameof(Database), value);

}

}

string? _database;

/// <summary>

/// The username to connect with. Not required if using IntegratedSecurity.

/// </summary>

[Category("Connection")]

[Description("The username to connect with. Not required if using IntegratedSecurity.")]

[DisplayName("Username")]

[NpgsqlConnectionStringProperty("User Name", "UserId", "User Id", "UID")]

public string? Username

{

get => _username;

set

{

_username = value;

SetValue(nameof(Username), value);

}

}

string? _username;

/// <summary>

/// The password to connect with. Not required if using IntegratedSecurity.

/// </summary>

[Category("Connection")]

[Description("The password to connect with. Not required if using IntegratedSecurity.")]

[PasswordPropertyText(true)]

[DisplayName("Password")]

[NpgsqlConnectionStringProperty("PSW", "PWD")]

public string? Password

{

get => _password;

set

{

_password = value;

SetValue(nameof(Password), value);

}

}

string? _password;

/// <summary>

/// Path to a PostgreSQL password file (PGPASSFILE), from which the password would be taken.

/// </summary>

[Category("Connection")]

[Description("Path to a PostgreSQL password file (PGPASSFILE), from which the password would be taken.")]

[DisplayName("Passfile")]

[NpgsqlConnectionStringProperty]

public string? Passfile

{

get => _passfile;

set

{

_passfile = value;

SetValue(nameof(Passfile), value);

}

}

string? _passfile;

/// <summary>

/// The optional application name parameter to be sent to the backend during connection initiation.

/// </summary>

[Category("Connection")]

[Description("The optional application name parameter to be sent to the backend during connection initiation")]

[DisplayName("Application Name")]

[NpgsqlConnectionStringProperty]

public string? ApplicationName

{

get => _applicationName;

set

{

_applicationName = value;

SetValue(nameof(ApplicationName), value);

}

}

string? _applicationName;

/// <summary>

/// Whether to enlist in an ambient TransactionScope.

/// </summary>

[Category("Connection")]

[Description("Whether to enlist in an ambient TransactionScope.")]

[DisplayName("Enlist")]

[DefaultValue(true)]

[NpgsqlConnectionStringProperty]

public bool Enlist

{

get => _enlist;

set

{

_enlist = value;

SetValue(nameof(Enlist), value);

}

}

bool _enlist;

/// <summary>

/// Gets or sets the schema search path.

/// </summary>

[Category("Connection")]

[Description("Gets or sets the schema search path.")]

[DisplayName("Search Path")]

[NpgsqlConnectionStringProperty]

public string? SearchPath

{

get => _searchPath;

set

{

_searchPath = value;

SetValue(nameof(SearchPath), value);

}

}

string? _searchPath;

/// <summary>

/// Gets or sets the client_encoding parameter.

/// </summary>

[Category("Connection")]

[Description("Gets or sets the client_encoding parameter.")]

[DisplayName("Client Encoding")]

[NpgsqlConnectionStringProperty]

public string? ClientEncoding

{

get => _clientEncoding;

set

{

_clientEncoding = value;

SetValue(nameof(ClientEncoding), value);

}

}

string? _clientEncoding;

/// <summary>

/// Gets or sets the .NET encoding that will be used to encode/decode PostgreSQL string data.

/// </summary>

[Category("Connection")]

[Description("Gets or sets the .NET encoding that will be used to encode/decode PostgreSQL string data.")]

[DisplayName("Encoding")]

[DefaultValue("UTF8")]

[NpgsqlConnectionStringProperty]

public string Encoding

{

get => _encoding;

set

{

_encoding = value;

SetValue(nameof(Encoding), value);

}

}

string _encoding = "UTF8";

/// <summary>

/// Gets or sets the PostgreSQL session timezone, in Olson/IANA database format.

/// </summary>

[Category("Connection")]

[Description("Gets or sets the PostgreSQL session timezone, in Olson/IANA database format.")]

[DisplayName("Timezone")]

[NpgsqlConnectionStringProperty]

public string? Timezone

{

get => _timezone;

set

{

_timezone = value;

SetValue(nameof(Timezone), value);

}

}

string? _timezone;

#endregion

#region Properties - Security

/// <summary>

/// Controls whether SSL is required, disabled or preferred, depending on server support.

/// </summary>

[Category("Security")]

[Description("Controls whether SSL is required, disabled or preferred, depending on server support.")]

[DisplayName("SSL Mode")]

[NpgsqlConnectionStringProperty]

public SslMode SslMode

{

get => _sslMode;

set

{

_sslMode = value;

SetValue(nameof(SslMode), value);

}

}

SslMode _sslMode;

/// <summary>

/// Whether to trust the server certificate without validating it.

/// </summary>

[Category("Security")]

[Description("Whether to trust the server certificate without validating it.")]

[DisplayName("Trust Server Certificate")]

[NpgsqlConnectionStringProperty]

public bool TrustServerCertificate

{

get => _trustServerCertificate;

set

{

_trustServerCertificate = value;

SetValue(nameof(TrustServerCertificate), value);

}

}

bool _trustServerCertificate;

/// <summary>

/// Location of a client certificate to be sent to the server.

/// </summary>

[Category("Security")]

[Description("Location of a client certificate to be sent to the server.")]

[DisplayName("Client Certificate")]

[NpgsqlConnectionStringProperty]

public string? ClientCertificate

{

get => _clientCertificate;

set

{

_clientCertificate = value;

SetValue(nameof(ClientCertificate), value);

}

}

string? _clientCertificate;

/// <summary>

/// Key for a client certificate to be sent to the server.

/// </summary>

[Category("Security")]

[Description("Key for a client certificate to be sent to the server.")]

[DisplayName("Client Certificate Key")]

[NpgsqlConnectionStringProperty]

public string? ClientCertificateKey

{

get => _clientCertificateKey;

set

{

_clientCertificateKey = value;

SetValue(nameof(ClientCertificateKey), value);

}

}

string? _clientCertificateKey;

/// <summary>

/// Location of a CA certificate used to validate the server certificate.

/// </summary>

[Category("Security")]

[Description("Location of a CA certificate used to validate the server certificate.")]

[DisplayName("Root Certificate")]

[NpgsqlConnectionStringProperty]

public string? RootCertificate

{

get => _rootCertificate;

set

{

_rootCertificate = value;

SetValue(nameof(RootCertificate), value);

}

}

string? _rootCertificate;

/// <summary>

/// Whether to check the certificate revocation list during authentication.

/// False by default.

/// </summary>

[Category("Security")]

[Description("Whether to check the certificate revocation list during authentication.")]

[DisplayName("Check Certificate Revocation")]

[NpgsqlConnectionStringProperty]

public bool CheckCertificateRevocation

{

get => _checkCertificateRevocation;

set

{

_checkCertificateRevocation = value;

SetValue(nameof(CheckCertificateRevocation), value);

}

}

bool _checkCertificateRevocation;

/// <summary>

/// Whether to use Windows integrated security to log in.

/// </summary>

[Category("Security")]

[Description("Whether to use Windows integrated security to log in.")]

[DisplayName("Integrated Security")]

[NpgsqlConnectionStringProperty]

public bool IntegratedSecurity

{

get => _integratedSecurity;

set

{

// No integrated security if we're on mono and .NET 4.5 because of ClaimsIdentity,

// see https://github.com/npgsql/Npgsql/issues/133

if (value && Type.GetType("Mono.Runtime") != null)

throw new NotSupportedException("IntegratedSecurity is currently unsupported on mono and .NET 4.5 (see https://github.com/npgsql/Npgsql/issues/133)");

_integratedSecurity = value;

SetValue(nameof(IntegratedSecurity), value);

}

}

bool _integratedSecurity;

/// <summary>

/// The Kerberos service name to be used for authentication.

/// </summary>

[Category("Security")]

[Description("The Kerberos service name to be used for authentication.")]

[DisplayName("Kerberos Service Name")]

[NpgsqlConnectionStringProperty("Krbsrvname")]

[DefaultValue("postgres")]

public string KerberosServiceName

{

get => _kerberosServiceName;

set

{

_kerberosServiceName = value;

SetValue(nameof(KerberosServiceName), value);

}

}

string _kerberosServiceName = "postgres";

/// <summary>

/// The Kerberos realm to be used for authentication.

/// </summary>

[Category("Security")]

[Description("The Kerberos realm to be used for authentication.")]

[DisplayName("Include Realm")]

[NpgsqlConnectionStringProperty]

public bool IncludeRealm

{

get => _includeRealm;

set

{

_includeRealm = value;

SetValue(nameof(IncludeRealm), value);

}

}

bool _includeRealm;

/// <summary>

/// Gets or sets a Boolean value that indicates if security-sensitive information, such as the password, is not returned as part of the connection if the connection is open or has ever been in an open state.

/// </summary>

[Category("Security")]

[Description("Gets or sets a Boolean value that indicates if security-sensitive information, such as the password, is not returned as part of the connection if the connection is open or has ever been in an open state.")]

[DisplayName("Persist Security Info")]

[NpgsqlConnectionStringProperty]

public bool PersistSecurityInfo

{

get => _persistSecurityInfo;

set

{

_persistSecurityInfo = value;

SetValue(nameof(PersistSecurityInfo), value);

}

}

bool _persistSecurityInfo;

/// <summary>

/// When enabled, parameter values are logged when commands are executed. Defaults to false.

/// </summary>

[Category("Security")]

[Description("When enabled, parameter values are logged when commands are executed. Defaults to false.")]

[DisplayName("Log Parameters")]

[NpgsqlConnectionStringProperty]

public bool LogParameters

{

get => _logParameters;

set

{

_logParameters = value;

SetValue(nameof(LogParameters), value);

}

}

bool _logParameters;

internal const string IncludeExceptionDetailDisplayName = "Include Error Detail";

/// <summary>

/// When enabled, PostgreSQL error details are included on <see cref="PostgresException.Detail" /> and

/// <see cref="PostgresNotice.Detail" />. These can contain sensitive data.

/// </summary>

[Category("Security")]

[Description("When enabled, PostgreSQL error and notice details are included on PostgresException.Detail and PostgresNotice.Detail. These can contain sensitive data.")]

[DisplayName(IncludeExceptionDetailDisplayName)]

[NpgsqlConnectionStringProperty]

public bool IncludeErrorDetails

{

get => _includeErrorDetails;

set

{

_includeErrorDetails = value;

SetValue(nameof(IncludeErrorDetails), value);

}

}

bool _includeErrorDetails;

#endregion

#region Properties - Pooling

/// <summary>

/// Whether connection pooling should be used.

/// </summary>

[Category("Pooling")]

[Description("Whether connection pooling should be used.")]

[DisplayName("Pooling")]

[NpgsqlConnectionStringProperty]

[DefaultValue(true)]

public bool Pooling

{

get => _pooling;

set

{

_pooling = value;

SetValue(nameof(Pooling), value);

}

}

bool _pooling;

/// <summary>

/// The minimum connection pool size.

/// </summary>

[Category("Pooling")]

[Description("The minimum connection pool size.")]

[DisplayName("Minimum Pool Size")]

[NpgsqlConnectionStringProperty]

[DefaultValue(0)]

public int MinPoolSize

{

get => _minPoolSize;

set

{

if (value < 0)

throw new ArgumentOutOfRangeException(nameof(value), value, "MinPoolSize can't be negative");

_minPoolSize = value;

SetValue(nameof(MinPoolSize), value);

}

}

int _minPoolSize;

/// <summary>

/// The maximum connection pool size.

/// </summary>

[Category("Pooling")]

[Description("The maximum connection pool size.")]

[DisplayName("Maximum Pool Size")]

[NpgsqlConnectionStringProperty]

[DefaultValue(100)]

public int MaxPoolSize

{

get => _maxPoolSize;

set

{

if (value < 0)

throw new ArgumentOutOfRangeException(nameof(value), value, "MaxPoolSize can't be negative");

_maxPoolSize = value;

SetValue(nameof(MaxPoolSize), value);

}

}

int _maxPoolSize;

/// <summary>

/// The time to wait before closing idle connections in the pool if the count

/// of all connections exceeds MinPoolSize.

/// </summary>

/// <value>The time (in seconds) to wait. The default value is 300.</value>

[Category("Pooling")]

[Description("The time to wait before closing unused connections in the pool if the count of all connections exceeds MinPoolSize.")]

[DisplayName("Connection Idle Lifetime")]

[NpgsqlConnectionStringProperty]

[DefaultValue(300)]

public int ConnectionIdleLifetime

{

get => _connectionIdleLifetime;

set

{

_connectionIdleLifetime = value;

SetValue(nameof(ConnectionIdleLifetime), value);

}

}

int _connectionIdleLifetime;

/// <summary>

/// How many seconds the pool waits before attempting to prune idle connections that are beyond

/// idle lifetime (<see cref="ConnectionIdleLifetime"/>.

/// </summary>

/// <value>The interval (in seconds). The default value is 10.</value>

[Category("Pooling")]

[Description("How many seconds the pool waits before attempting to prune idle connections that are beyond idle lifetime.")]

[DisplayName("Connection Pruning Interval")]

[NpgsqlConnectionStringProperty]

[DefaultValue(10)]

public int ConnectionPruningInterval

{

get => _connectionPruningInterval;

set

{

_connectionPruningInterval = value;

SetValue(nameof(ConnectionPruningInterval), value);

}

}

int _connectionPruningInterval;

/// <summary>

/// The total maximum lifetime of connections (in seconds). Connections which have exceeded this value will be

/// destroyed instead of returned from the pool. This is useful in clustered configurations to force load

/// balancing between a running server and a server just brought online.

/// </summary>

/// <value>The time (in seconds) to wait, or 0 to to make connections last indefinitely (the default).</value>

[Category("Pooling")]

[Description("The total maximum lifetime of connections (in seconds).")]

[DisplayName("Connection Lifetime")]

[NpgsqlConnectionStringProperty("Load Balance Timeout")]

[DefaultValue(0)]

public int ConnectionLifetime

{

get => _connectionLifetime;

set

{

_connectionLifetime = value;

SetValue(nameof(ConnectionLifetime), value);

}

}

int _connectionLifetime;

#endregion

#region Properties - Timeouts

/// <summary>

/// The time to wait (in seconds) while trying to establish a connection before terminating the attempt and generating an error.

/// Defaults to 15 seconds.

/// </summary>

[Category("Timeouts")]

[Description("The time to wait (in seconds) while trying to establish a connection before terminating the attempt and generating an error.")]

[DisplayName("Timeout")]

[NpgsqlConnectionStringProperty]

[DefaultValue(DefaultTimeout)]

public int Timeout

{

get => _timeout;

set

{

if (value < 0 || value > NpgsqlConnection.TimeoutLimit)

throw new ArgumentOutOfRangeException(nameof(value), value, "Timeout must be between 0 and " + NpgsqlConnection.TimeoutLimit);

_timeout = value;

SetValue(nameof(Timeout), value);

}

}

int _timeout;

internal const int DefaultTimeout = 15;

/// <summary>

/// The time to wait (in seconds) while trying to execute a command before terminating the attempt and generating an error.

/// Defaults to 30 seconds.

/// </summary>

[Category("Timeouts")]

[Description("The time to wait (in seconds) while trying to execute a command before terminating the attempt and generating an error. Set to zero for infinity.")]

[DisplayName("Command Timeout")]

[NpgsqlConnectionStringProperty]

[DefaultValue(NpgsqlCommand.DefaultTimeout)]

public int CommandTimeout

{

get => _commandTimeout;

set

{

if (value < 0)

throw new ArgumentOutOfRangeException(nameof(value), value, "CommandTimeout can't be negative");

_commandTimeout = value;

SetValue(nameof(CommandTimeout), value);

}

}

int _commandTimeout;

/// <summary>

/// The time to wait (in seconds) while trying to execute a an internal command before terminating the attempt and generating an error.

/// </summary>

[Category("Timeouts")]

[Description("The time to wait (in seconds) while trying to execute a an internal command before terminating the attempt and generating an error. -1 uses CommandTimeout, 0 means no timeout.")]

[DisplayName("Internal Command Timeout")]

[NpgsqlConnectionStringProperty]

[DefaultValue(-1)]

public int InternalCommandTimeout

{

get => _internalCommandTimeout;

set

{

if (value != 0 && value != -1 && value < NpgsqlConnector.MinimumInternalCommandTimeout)

throw new ArgumentOutOfRangeException(nameof(value), value,

$"InternalCommandTimeout must be >= {NpgsqlConnector.MinimumInternalCommandTimeout}, 0 (infinite) or -1 (use CommandTimeout)");

_internalCommandTimeout = value;

SetValue(nameof(InternalCommandTimeout), value);

}

}

int _internalCommandTimeout;

/// <summary>

/// The time to wait (in milliseconds) while trying to read a response for a cancellation request for a timed out or cancelled query, before terminating the attempt and generating an error.

/// Defaults to 2000 milliseconds.

/// </summary>

[Category("Timeouts")]

[Description("After Command Timeout is reached (or user supplied cancellation token is cancelled) and command cancellation is attempted, Npgsql waits for this additional timeout (in milliseconds) before breaking the connection. Defaults to 2000, set to zero for infinity.")]

[DisplayName("Cancellation Timeout")]

[NpgsqlConnectionStringProperty]

[DefaultValue(2000)]

public int CancellationTimeout

{

get => _cancellationTimeout;

set

{

if (value < 0)

throw new ArgumentOutOfRangeException(nameof(value), value, $"{nameof(CancellationTimeout)} can't be negative");

_cancellationTimeout = value;

SetValue(nameof(CancellationTimeout), value);

}

}

int _cancellationTimeout;

#endregion

#region Properties - Entity Framework

/// <summary>

/// The database template to specify when creating a database in Entity Framework. If not specified,

/// PostgreSQL defaults to "template1".

/// </summary>

/// <remarks>

/// https://www.postgresql.org/docs/current/static/manage-ag-templatedbs.html

/// </remarks>

[Category("Entity Framework")]

[Description("The database template to specify when creating a database in Entity Framework. If not specified, PostgreSQL defaults to \"template1\".")]

[DisplayName("EF Template Database")]

[NpgsqlConnectionStringProperty]

public string? EntityTemplateDatabase

{

get => _entityTemplateDatabase;

set

{

_entityTemplateDatabase = value;

SetValue(nameof(EntityTemplateDatabase), value);

}

}

string? _entityTemplateDatabase;

/// <summary>

/// The database admin to specify when creating and dropping a database in Entity Framework. This is needed because

/// Npgsql needs to connect to a database in order to send the create/drop database command.

/// If not specified, defaults to "template1". Check NpgsqlServices.UsingPostgresDBConnection for more information.

/// </summary>

[Category("Entity Framework")]

[Description("The database admin to specify when creating and dropping a database in Entity Framework. If not specified, defaults to \"template1\".")]

[DisplayName("EF Admin Database")]

[NpgsqlConnectionStringProperty]

public string? EntityAdminDatabase

{