]]>

Gets or sets the description of the setting.

The description of the setting.

Gets or sets a boolean value that indicates whether the setting value is to be encrypted.

true, if the setting value is to be encrypted; otherwise false.

Gets or sets the .

Represents a collection of objects.

Sets the key to be used for encrypting and decrypting setting values.

New crypto key.

Gets the index of the specified object.

The object whose index is to be retrieved. Index of the specified object if found; otherwise -1.

Adds a new object if one does not exist.

Name of the object. Value of the object.

Adds a new object if one does not exist.

Name of the object. Value of the object. Description of the object.

Adds a new object if one does not exist.

Name of the object. Value of the object. Description of the object. true if the Value of object is to be encrypted; otherwise false.

Adds a new object if one does not exist.

Name of the object. Value of the object. Description of the object. true if the Value of object is to be encrypted; otherwise false. One of the values.

Adds a new object if one does not exist.

The object to add.

Removes a object if it exists.

Name of the object to remove.

Removes a object if it exists.

The object to remove.

Removes the object at the specified index location.

Index location of the object to remove.

Removes all existing objects.

Creates a new object.

Instance of .

Creates a new object.

Name identifying the object. Instance of .

Gets the key for a object.

object whose key is to be retrieved. String key value for a object.

Gets or sets the name of the .

Gets or sets the to which this belongs.

Gets or sets the object at the specified index.

Zero-based index for the object to retrieve. The object at the specified index if it exists; otherwise null.

Gets the object with the specified name.

Name of the object to retrieve. The object with the specified name if it exists; otherwise null.

Gets the object with the specified name.

Name of the object to retrieve. true if the object is to be created if it does not exist; otherwise false. The object with the specified name if it exists; otherwise null.

Represents a section in the config file with one or more representing categories, each containing one or more objects representing settings under a specific category.

Sets the key to be used for encrypting and decrypting setting values.

New crypto key.

Removes the specified category name including its associated settings.

Name of the category to be removed. is null or empty string.

Reads XML from the configuration file.

The object, which reads from the configuration file.

Gets or sets the to which this belongs.

Gets the object representing settings under the specified category name.

Name of the category whose settings are to be retrieved. object with settings under the specified category name. is null or empty string.

Gets the object representing settings under "general" category.

object with settings under the "general" category.

Represents a configuration file of a Windows or Web application.

This example shows how to save and read settings from the config file:


            using System;
            using System.Configuration;
            using GSF;
            using GSF.Configuration;
            
            class Program
            {
                static void Main(string[] args)
                {
                    // Get the application config file.
                    ConfigurationFile config = ConfigurationFile.Current;
            
                    // Get the sections of config file.
                    CategorizedSettingsElementCollection startup = config.Settings["Startup"];
                    CategorizedSettingsElementCollection passwords = config.Settings["Passwords"];
                    CategorizedSettingsElementCollection monitoring = config.Settings["Monitoring"];
                    KeyValueConfigurationCollection appSettings = config.Configuration.AppSettings.Settings;
                    ConnectionStringSettingsCollection connStrings = config.Configuration.ConnectionStrings.ConnectionStrings;
            
                    // Add settings to the config file under the "appSettings" section.
                    appSettings.Add("SaveSettingOnExit", true.ToString());
                    // Add settings to the config file under the "connectionStrings" section.
                    connStrings.Add(new ConnectionStringSettings("DevSql", "Server=SqlServer;Database=Sandbox;Trusted_Connection=True"));
                    // Add settings to the config (if they don't exist) under a custom "monitoring" section.
                    monitoring.Add("RefreshInterval", 5, "Interval in seconds at which the Monitor screen is to be refreshed.");
                    monitoring.Add("MessagesSnapshot", 30000, "Maximum messages length to be displayed on the Monitor screen.");
                    // Add password to the config file encrypted (if it doesn't exist) under a custom "passwords" section.
                    passwords.Add("Admin", "Adm1nP4ss", "Password used for performing administrative tasks.", true);
                    // Add user-scope setting to the config (if it doesn't exist) under a custom "startup" section.
                    startup.Add("Theme", "Default", "Application theme to use for the session.", false, SettingScope.User);
                    config.Save();  // Save settings to the config file.
            
                    // Read saved settings from the config file.
                    bool saveSettingsOnExit = appSettings["SaveSettingOnExit"].Value.ParseBoolean();
                    string devConnectionString = connStrings["DevSql"].ConnectionString;
                    string appTheme = startup["Theme"].Value;
                    string adminPassword = passwords["Admin"].Value;
                    int refreshInterval = monitoring["RefreshInterval"].ValueAsInt32();
                    int messagesSnapshot = monitoring["MessagesSnapshot"].ValueAsInt32();
            
                    // Print the retrieved settings to the console.
                    Console.WriteLine("SaveSettingOnExit = {0}", saveSettingsOnExit);
                    Console.WriteLine("DevSql = {0}", devConnectionString);
                    Console.WriteLine("Theme = {0}", appTheme);
                    Console.WriteLine("Admin = {0}", adminPassword);
                    Console.WriteLine("RefreshInterval = {0}", refreshInterval);
                    Console.WriteLine("MessagesSnapshot = {0}", messagesSnapshot);
            
                    Console.ReadLine();
                }
            }

This example shows the content of the config file from the sample code above:

]]>

Initializes a new instance of the class.

Writes the configuration settings contained within this object to the configuration file that it represents.

One of the values.

Writes the configuration settings contained within this object to the specified configuration file.

The path and file name to save the configuration file to.

Reloads the current configuration settings from the configuration file that the represents.

Restores all the default settings for scoped settings.

Sets the key to be used for encrypting and decrypting values of .

New crypto key.

Opens application config file at the specified .

Path of the config file that belongs to a Windows or Web application. An object.

Gets or sets the to use for the conversion of setting values to and from .

Get the underlying that can be accessed using this object.

Gets the object representing settings under the "categorizedSettings" section of the config file.

Gets the where user specific settings are saved.

Gets the object that represents the config file of the currently executing Windows or Web application.

Parses connection strings based on a settings object whose properties are annotated with the .

Default value for the property.

Creates a new instance of the class.

Serializes the given into a connection string.

The object whose properties are to be serialized. A connection string containing the serialized properties.

Deserializes the connection string parameters into the given .

The connection string to be parsed. The object whose properties are to be populated with values from the connection string. is null. A required connection string parameter cannot be found in the connection string.

Gets the set of properties which are part of the connection string.

The type of the settings object used to look up properties via reflection. The set of properties which are part of the connection string.

Converts the given string value to the type of the given property.

The string value to be converted. The property used to determine what type to convert to. The given string converted to the type of the given property.

Converts the given object to a string.

The object to be converted. The property which defines the type of the object. The object converted to a string.

Gets or sets the parameter delimiter used to separate key-value pairs in the connection string.

Gets or sets the key-value delimiter used to separate keys from values in the connection string.

Gets or sets the start value delimiter used to denote the start of a value in the cases where the value contains one of the delimiters defined for the connection string.

Gets or sets the end value delimiter used to denote the end of a value in the cases where the value contains one of the delimiters defined for the connection string.

Gets or sets the flag that determines whether to explicitly specify parameter values that match their defaults when serializing settings to a connection string.

Gets or sets the flag that determines whether to include properties which are not annotated with the in the connection string.

Stores reflected information from a object used to parse connection strings.

The object.

The type converter used to convert the value of this property to and from a string.

The name of the property as it appears in the connection string.

The default value of the property if its value is not explicitly specified in the connection string.

Indicates whether or not the property is required to be explicitly defined in the connection string.

Creates a new instance of the class.

The object.

Parses connection strings based on a settings object whose properties are annotated with .

The type of the attribute to search for when determining whether to serialize a property to the connection string.

Gets the set of properties which are part of the connection string.

The type of the settings object used to look up properties via reflection. The set of properties which are part of the connection string.

Redefined to throw an exception. This property has no meaning when property serialization is determined by the existence of the typed parameter.

Represents an attribute that determines if a property or field in a class derived from or should be encrypted when it is serialized to the configuration file.

Creates a new ; defaults to = true.

Creates a new with the specified value.

Assigns flag that determines if the property or field this modifies should be encrypted when serialized to the configuration file.

Gets or sets flag that determines if the property or field this modifies should be encrypted when serialized to the configuration file.

Gets or sets optional encryption key that will be used on a setting for added security.

This key is not the actual key used for encryption, it is used for hash lookup of the actual AES key. If this key is not specified, the property name will be used for the hash lookup.

Represents the base class for application settings that are synchronized to an INI file.

In order to make custom types serializable for the INI file, implement a for the type.
See MSDN for details. Here is an example class derived from that automatically serializes its fields and properties to the INI file.


               public enum MyEnum
                {
                    One,
                    Two,
                    Three
                }
            
                public class MySettings : IniSettingsBase
                {
                    // Private property fields (private fields will not be serialized)
                    private double m_doubleVal;
            
                    // Public settings fields
                    public bool BoolVal = true;
                    public int IntVal = 1;
                    public float FloatVal = 3.14F;
                    public string StrVal = "This is a test...";
                    public MyEnum EnumVal = MyEnum.Three;
                    
                    [SettingName("UserOptions"), EncryptSetting()]
                    public string Password = "default";
            
                    // Mark this field to not be serialized to INI file...
                    [SerializeSetting(false)]
                    public decimal DecimalVal;
            
                    public MySettings()
                        : base(FilePath.GetAbsolutePath("MySettings.ini"), "GeneralSettings") {}
            
                    [Category("OtherSettings"), DefaultValue(1.159D)]
                    public double DoubleVal
                    {
                        get
                        {
                            return m_doubleVal;
                        }
                        set
                        {
                            m_doubleVal = value;
                        }
                    }
            
                    [SerializeSetting(false)]
                    public bool DontSerializeMe { get; set; }
                }

Creates a new instance of the class for the application's INI file.

Name of INI file to use for accessing settings. Name of default section to use to get and set settings from INI file.

Creates a new instance of the class for the application's INI file.

Name of INI file to use for accessing settings. Name of default section to use to get and set settings from INI file. Determines if category attributes will be used for section names. Assigns flag that determines if is required to exist before a field or property is serialized to the INI file. If is false, all settings will be placed in section labeled by the value; otherwise, if a exists on a field or property then the member value will serialized into the INI file in a section labeled the same as the value and if the attribute doesn't exist the member value will serialized into the section labeled by the value.

Creates a new instance of the class for the application's INI file.

INI file to use for accessing settings. Name of default section to use to get and set settings from INI file. Determines if category attributes will be used for section names. Assigns flag that determines if is required to exist before a field or property is serialized to the INI file. Determines if method should be called from constructor. If is false, all settings will be placed in section labeled by the value; otherwise, if a exists on a field or property then the member value will serialized into the INI file in a section labeled the same as the value and if the attribute doesn't exist the member value will serialized into the section labeled by the value. Note that some .NET languages (e.g., Visual Basic) will not initialize member elements before call to constuctor, in this case should be set to false, then the method should be called manually after all properties have been initialized. Alternately, consider using the on the fields or properties and this will be used to initialize the values.

Create setting in INI file if it doesn't already exist. This method is for internal use.

Field or property name, if useful (can be different from setting name). Setting name. Setting value.

Retrieves setting from INI file. This method is for internal use.

Field or property name, if useful (can be different from setting name). Setting name. Setting value.

Stores setting to INI file. This method is for internal use.

Field or property name, if useful (can be different from setting name). Setting name. Setting value.

Persists any pending changes to INI file. This method is for internal use.

Gets the section name to use for the specified field or property.

Field or property name. applied to specified field or property; or if attribute does not exist. cannot be null or empty. will only be returned if is true; otherwise value will be returned.

Gets or sets reference to working INI file.

value cannot be null.

Gets or sets default name of section used to access settings in INI file.

Gets or sets value that determines whether a applied to a field or property will be used for the section name.

If is false, all settings will be placed in section labeled by the value; otherwise, if a exists on a field or property then the member value will serialized into the INI file in a section labeled the same as the value and if the attribute doesn't exist the member value will serialized into the section labeled by the value.

Contains classes, base classes and attributes related to simplifying access to configuration files including creating a categorized settings section.

Represents the base class for application settings that are synchronized to the registry.

In order to make custom types serializable for the registry, implement a for the type.
See MSDN for details. Here is an example class derived from that automatically serializes its fields and properties to the registry.


               public enum MyEnum
                {
                    One,
                    Two,
                    Three
                }
            
                public class MySettings : RegistrySettingsBase
                {
                    // Private property fields (private fields will not be serialized)
                    private double m_doubleVal;
            
                    // Public settings fields
                    public bool BoolVal = true;
                    public int IntVal = 1;
                    public float FloatVal = 3.14F;
                    public string StrVal = "This is a test...";
                    public MyEnum EnumVal = MyEnum.Three;
                    
                    [SettingName("UserOptions"), EncryptSetting()]
                    public string Password = "default";
            
                    // Mark this field to not be serialized to registry...
                    [SerializeSetting(false)]
                    public decimal DecimalVal;
            
                    public MySettings()
                        : base("HKEY_CURRENT_USER\\Software\\My Company\\My Product\\", "General Settings") {}
            
                    [Category("OtherSettings"), DefaultValue(1.159D)]
                    public double DoubleVal
                    {
                        get
                        {
                            return m_doubleVal;
                        }
                        set
                        {
                            m_doubleVal = value;
                        }
                    }
            
                    [SerializeSetting(false)]
                    public bool DontSerializeMe { get; set; }
                }

Creates a new instance of the class for the application's registry based settings.

Defines the root registry path used to access settings in the registry (e.g., "HKEY_CURRENT_USER\\Software\\My Company\\My Product\\"). Defines the name of default key used to access settings in the registry (e.g., "General Settings"). Determines if category attributes will be used for the registry key names. Assigns flag that determines if is required to exist before a field or property is serialized to the registry. Determines if method should be called from constructor. If is false, all settings will be placed in section labeled by the value; otherwise, if a exists on a field or property then the member value will serialized into the registry in a section labeled the same as the value and if the attribute doesn't exist the member value will serialized into the section labeled by the value. Note that some .NET languages (e.g., Visual Basic) will not initialize member elements before call to constuctor, in this case should be set to false, then the method should be called manually after all properties have been initialized. Alternately, consider using the on the fields or properties and this will be used to initialize the values.

Create setting in registry if it doesn't already exist. This method is for internal use.

Field or property name, if useful (can be different from setting name). Setting name. Setting value.

Retrieves setting from registry. This method is for internal use.

Field or property name, if useful (can be different from setting name). Setting name. Setting value.

Stores setting to registry. This method is for internal use.

Field or property name, if useful (can be different from setting name). Setting name. Setting value.

Persist any pending changes to registry. This method is for internal use.

Gets the key name to use for storing the specified field or property in the registry.

Field or property name. applied to specified field or property; or if attribute does not exist. cannot be null or empty. will only be returned if is true; otherwise value will be returned.

Gets or sets root registry path used to access settings in the registry (e.g., "HKEY_CURRENT_USER\\Software\\My Company\\My Product\\").

Gets or sets name of default key used to access settings in the registry (e.g., "General Settings").

Gets or sets value that determines whether a applied to a field or property will be used for the registry key names.

If is false, all settings will be placed in section labeled by the value; otherwise, if a exists on a field or property then the member value will serialized into the registry in a section labeled the same as the value and if the attribute doesn't exist the member value will stored in the registry key identified by the value.

Represents an attribute that determines if a property or field in a class derived from or should be serialized to the configuration file.

Creates a new ; defaults to = true.

Creates a new with the specified value.

Assigns flag that determines if the property or field this modifies should be serialized to the configuration file.

Gets or sets flag that determines if the property or field this modifies should be serialized to the configuration file.

Represents an attribute that defines the setting name of a property or field in a class derived from or when serializing the value to the configuration file.

This attribute allows consumers to override the name of the setting going into the configuration file, if the attribute doesn't exist the property or field name is used.

Creates a new with the specified value.

Assigns name(s) used to serialize setting into config file.

Gets the name used to serialize field or property into config file.

Gets the names used to serialize field or property into config file.

Represents an ordered set of arguments along with optional arguments parsed from a command-line.

This example shows how to parse a command-line command that does not contain an executable name:


             using System;
             using GSF;
             using GSF.Console;
            
             class Program
             {
                 static void Main()
                 {
                     Arguments args = new Arguments("Sample.txt -wrap=true");
                     string file = args["OrderedArg1"];
                     bool wrapText = args["wrap"].ParseBoolean();
                    
                     Console.WriteLine(string.Format("File: {0}", file));
                     Console.WriteLine(string.Format("Wrap text: {0}", wrapText));
                     Console.ReadLine();
                 }
             }

This example shows how to parse a command-line command that contains an executable name in it:


             using System;
             using GSF.Console;
            
             class Program
             {
                 static void Main()
                 {
                     // Environment.CommandLine = @"""c:\program files\tva\theme application\app.exe"" Document1.dcx -theme=default"
                     Arguments args = new Arguments(Environment.CommandLine, true);
                     string doc = args["OrderedArg1"];
                     string theme = args["theme"];
                    
                     Console.WriteLine(string.Format("Document: {0}", doc));
                     Console.WriteLine(string.Format("Application theme: {0}", theme));
                     Console.ReadLine();
                 }
             }

Initializes a new instance of the class.

The command-line command to be parsed.

Initializes a new instance of the class.

The command-line command to be parsed. true if the first argument in the command-line command is to be skipped from being processed; otherwise false.

Initializes a new instance of the class.

The command-line command to be parsed. The prefix to be used in the identifier of ordered arguments.

Initializes a new instance of the class.

The command-line command to be parsed. The prefix to be used in the identifier of ordered arguments. true if the first argument in the command-line command is to be skipped from being processed; otherwise false.

Gets the value associated with the specified argument in the command-line command.

The argument whose value is to be retrieved. Value associated with the specified argument if it exists in the command-line command, otherwise null. true if argument existed and was returned; otherwise false.

Gets a boolean value that indicates whether the specified argument is present in the command-line command.

The argument to be checked. true if the argument exists in the command-line command; otherwise false.

Gets a string representation of the object.

A string representation of the object.

Returns an for iterating through all the command-line command arguments.

An for the command-line command arguments.

Returns an for iterating through all the command-line command arguments.

An for the command-line command arguments.

This function can be used to parse a single parameterized string and turn it into an array of parameters.

String of parameters. Array of parameters.

Gets the value for the specified argument from the command-line command.

The argument whose value is to retrieved. Value for the specified argument if found; otherwise null.

Gets the total number of arguments (ordered and optional) present in the command-line command.

Gets the prefix text in the identifier of ordered arguments present in the command-line command.

Gets the total number of ordered arguments in the command-line command.

Gets the ordered arguments as an array of strings.

Gets a boolean value that indicates whether the command-line command contains request for displaying help.

Gets the dictionary containing all of the arguments present in the command-line command.

Defines a set of consumable events that can be raised by a console application.

Note that no events will be raised by this class when running under Mono deployments, the class remains available in the Mono build as a stub to allow existing code to still compile and run. This example shows how to subscribe to console application events:


             using System;
             using GSF.Console;
            
             class Program
             {
                 static void Main(string[] args)
                 {
                     // Subscribe to console events.
                     Events.CancelKeyPress += Events_CancelKeyPress;
                     Events.ConsoleClosing += Events_ConsoleClosing;
                     Events.EnableRaisingEvents();
                    
                     Console.ReadLine();
                 }
                
                 static void Events_CancelKeyPress(object sender, System.ComponentModel.CancelEventArgs e)
                 {
                     // Abort processing.
                 }
                
                 static void Events_ConsoleClosing(object sender, System.ComponentModel.CancelEventArgs e)
                 {
                     // Put clean-up code.
                 }
             }

Enables the raising of console application . Prior to calling this method, handlers must be defined for the raised by a console application.

This method is currently ignored under Mono deployments.

Enables the raising of console application .

This method is currently ignored under Mono deployments.

Delegate method that gets called when console application events occur.

Occurs when CTRL+C signal is received from keyboard input.

method must be called to enable event publication.

Occurs when CTRL+BREAK signal is received from keyboard input.

method must be called to enable event publication.

Occurs when the user closes the console application window.

method must be called to enable event publication.

Occurs when the user is logging off.

method must be called to enable event publication.

Occurs when the system is shutting down.

method must be called to enable event publication.

Contains classes used for parsing command line parameters and managing console applications.

Specifies the database type underlying an .

Underlying ADO database type is Microsoft Access.

Underlying ADO database type is SQL Server.

Underlying ADO database type is MySQL.

Underlying ADO database type is Oracle.

Underlying ADO database type is SQLite.

Underlying ADO database type is unknown.

Creates a new from any specified or configured ADO.NET data source.

Example connection and data provider strings: Database type Example connection string / data provider string SQL Server ConnectionString = "Data Source=serverName; Initial Catalog=databaseName; User ID=userName; Password=password"
DataProviderString = "AssemblyName={System.Data, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089}; ConnectionType=System.Data.SqlClient.SqlConnection; AdapterType=System.Data.SqlClient.SqlDataAdapter" Oracle ConnectionString = "Data Source=tnsName; User ID=schemaUserName; Password=schemaPassword"
DataProviderString = "AssemblyName={Oracle.DataAccess, Version=2.112.2.0, Culture=neutral, PublicKeyToken=89b483f429c47342}; ConnectionType=Oracle.DataAccess.Client.OracleConnection; AdapterType=Oracle.DataAccess.Client.OracleDataAdapter" MySQL ConnectionString = "Server=serverName; Database=databaseName; Uid=root; Pwd=password; allow user variables = true"
DataProviderString = "AssemblyName={MySql.Data, Version=6.3.6.0, Culture=neutral, PublicKeyToken=c5687fc88969c44d}; ConnectionType=MySql.Data.MySqlClient.MySqlConnection; AdapterType=MySql.Data.MySqlClient.MySqlDataAdapter" SQLite ConnectionString = "Data Source=databaseName.db; Version=3"
DataProviderString = "AssemblyName={System.Data.SQLite, Version=1.0.74.0, Culture=neutral, PublicKeyToken=db937bc2d44ff139}; ConnectionType=System.Data.SQLite.SQLiteConnection; AdapterType=System.Data.SQLite.SQLiteDataAdapter" Access / OleDB ConnectionString = "Provider=Microsoft.Jet.OLEDB.4.0; Data Source=databaseName.mdb"
DataProviderString = "AssemblyName={System.Data, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089}; ConnectionType=System.Data.OleDb.OleDbConnection; AdapterType=System.Data.OleDb.OleDbDataAdapter" ODBC Connection ConnectionString = "Driver={SQL Server Native Client 10.0}; Server=serverName; Database=databaseName; Uid=userName; Pwd=password"
DataProviderString = "AssemblyName={System.Data, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089}; ConnectionType=System.Data.Odbc.OdbcConnection; AdapterType=System.Data.Odbc.OdbcDataAdapter" Example configuration file that defines connection settings:

]]>

Creates and opens a new based on connection settings in configuration file.

Settings category to use for connection settings.

Creates and opens a new from specified and .

Database specific ADO connection string. Key/value pairs that define which ADO assembly and types to load.

Releases the unmanaged resources before the object is reclaimed by .

Releases all the resources used by the object.

Releases the unmanaged resources used by the object and optionally releases the managed resources.

true to release both managed and unmanaged resources; false to release only unmanaged resources.

Returns proper implementation for connected database type.

to format per database type. Proper implementation for connected database type.

Returns proper implementation for connected database type.

to format per database type. Proper implementation for connected database type.

Retrieves from a field based on database type.

from which value needs to be retrieved. Name of the field which contains . .

Returns current UTC time in an implementation that is proper for connected database type.

Current UTC time in implementation that is proper for connected database type.

Gets the default for the connected database type.

Default for the connected database type.

Creates a parameterized query string for the underlying database type based on the given format string and parameter names.

A composite format string. A string array that contains zero or more parameter names to format. A parameterized query string based on the given format and parameter names.

Forces a reload of cached configuration connection settings.

Gets an open to configured ADO.NET data source.

Gets the type of data adapter for configured ADO.NET data source.

Gets or sets the type of the database underlying the .

This value is automatically assigned based on the adapter type specified in the data provider string, however, if the database type cannot be determined it will be set to . In this case, if you know the behavior of your custom ADO database connection matches that of another defined database type, you can manually assign the database type to allow for database interaction interoperability.

Gets a value to indicate whether source database is Microsoft Access.

Gets a value to indicate whether source database is Microsoft SQL Server.

Gets a value to indicate whether source database is MySQL.

Gets a value to indicate whether source database is Oracle.

Gets a value to indicate whether source database is SQLite.

Defines extension functions related to database and SQL interaction.

The default timeout duration used for executing SQL statements when timeout duration is not specified.

Performs SQL encoding on given SQL string.

The string on which SQL encoding is to be performed. Database type for the SQL encoding. The SQL encoded string.

Executes the SQL statement using , and returns the number of rows affected.

The SQL statement to be executed. The to use for executing the SQL statement. The parameter values to be used to fill in parameters identified by '@' prefix in expression. The number of rows affected. Type of to use.

Executes the SQL statement using , and returns the number of rows affected.

The SQL statement to be executed. The to use for executing the SQL statement. The time in seconds to wait for the SQL statement to execute. The parameter values to be used to fill in parameters identified by '@' prefix in expression. The number of rows affected. Type of to use.

Executes the SQL statement using , and returns the number of rows affected.

The SQL statement to be executed. The to use for executing the SQL statement. The parameter values to be used to fill in parameters identified by '@' prefix in expression -or- the parameter values to be passed into stored procedure being executed. The number of rows affected.

Executes the SQL statement using , and returns the number of rows affected.

Executes the SQL statement using , and builds a .

The SQL statement to be executed. The to use for executing the SQL statement. The parameter values to be used to fill in parameters identified by '@' prefix in expression. A object. Type of to use.

Executes the SQL statement using , and builds a .

The SQL statement to be executed. The to use for executing the SQL statement. One of the values. The time in seconds to wait for the SQL statement to execute. The parameter values to be used to fill in parameters identified by '@' prefix in expression. A object. Type of to use.

Executes the SQL statement using , and builds a .

The SQL statement to be executed. The to use for executing the SQL statement. The parameter values to be used to fill in parameters identified by '@' prefix in expression. A object.

Executes the SQL statement using , and builds a .

Executes the SQL statement using , and returns the value in the first column of the first row in the result set.

The SQL statement to be executed. The to use for executing the SQL statement. The parameter values to be used to fill in parameters identified by '@' prefix in expression. Value in the first column of the first row in the result set. Type of to use.

Executes the SQL statement using , and returns the value in the first column of the first row in the result set.

Executes the SQL statement using , and returns the first in the result set.

The SQL statement to be executed. The to use for executing the SQL statement. The first in the result set.

Executes the SQL statement using , and returns the first in the result set.

The SQL statement to be executed. The to use for executing the SQL statement. The time in seconds to wait for the SQL statement to execute. The first in the result set.