.NET (Core and Framework)

MSDN wrote:

If the SqlConnection goes out of scope, it won't be closed. Therefore, you must explicitly close the connection by calling Close or Dispose. Close and Dispose are functionally equivalent. If the connection pooling value Pooling is set to true or yes, the underlying connection is returned back to the connection pool. On the other hand, if Pooling is set to false or no, the underlying connection to the server is actually closed.

I are Troll

Sub New(whatever_arguments...)
  Try
    .. construct the object
  Catch
    Me.Dispose()
    Throw
  End Try
End Sub

using (SqlConnection conn = new SqlConnection(...)) {
    ....
    ....
    ....
}

SqlConnection conn = new SqlConnection(...);
try {
    ....
    ....
    ....
}
finally {
    if (conn is IDisposable) {
        conn.Dispose();
    }
}

public class SerialConfig : ConfigurationElement
    {
        /* *********************************** */
        /* This is the field I want to remove! */
        /* *********************************** */      
        // Fields
        [ConfigurationProperty("valid",
            DefaultValue = false,
            IsRequired = false)]
        //private int baud;
        public bool Valid
        {
            get
            {
                return (bool)this["valid"];
            }
            set
            {
                this["valid"] = (bool)value;
            }
        }


        [ConfigurationProperty("baud",
            DefaultValue = 115200,
            IsRequired = true)]
        //private int baud;
        public int Baud
        {
            get
            {
                return (int)this["baud"];
            }
            set
            {
                if((value == 115200) || (value == 9600))
                {
                    this["baud"] = value;
                }
                else
                {
                }
            }
        }

        [ConfigurationProperty("name",
            DefaultValue = "",
            IsRequired = true)]
        //private String name;
        public String Name
        {
            get
            {
                return (string)this["name"];
            }
            set
            {
                if (value.Contains("COM"))
                {
                    this["name"] = value;
                }
                else
                {
                    this["name"] = "INVALID";
                }
            }
        }
        
        // Constructors
        public SerialConfig(String name, int baud)
        {
            this["baud"] = baud;
            this["name"] = name;            
        }

        public SerialConfig(string name)
        {
            new SerialConfig(name, 115200);
        }

        public SerialConfig()
        {
            new SerialConfig("INVALID", 115200);
        }
    }

    // Define a custom section that is used by the application
    // to create custom configuration sections at the specified 
    // level in the configuration hierarchy that is in the 
    // proper configuration file.
    // This enables the user that has the proper access 
    // rights, to make changes to the configuration files.
    public class SerialConfigSection : ConfigurationSection
    {
        // Create a configuration section.
        public SerialConfigSection()
        {
            this["serialConfig"] = new SerialConfig();
        }

        // Set or get the SerialConfig. 
        [ConfigurationProperty("serialConfig")]
        public SerialConfig serialConfig
        {
            get
            {
                return (
                  (SerialConfig)this["serialConfig"]);
            }
            set
            {
                this["serialConfig"] = value;
            }
        }
    }

/// <summary>
/// Reads stored configuration settings from
/// ConfigurationUserLevel.PerUserRoamingAndLocal,
/// creating new default entries if corrupted or not present.
/// </summary>
public static void InitializeConfig()
{
    // Get the configuration that applies to the current user.
    Configuration userConfig =
        ConfigurationManager.OpenExeConfiguration(
            ConfigurationUserLevel.PerUserRoamingAndLocal);

    // Map the configuration file. This enables the application to access
    // the configuration file using the System.Configuration.Configuration
    // class
    ExeConfigurationFileMap configFileMap =
        new ExeConfigurationFileMap();
    configFileMap.ExeConfigFilename =
        userConfig.FilePath;

    // Get the mapped configuration file.
    config =
        ConfigurationManager.OpenMappedExeConfiguration(
            configFileMap, ConfigurationUserLevel.None);

    // Try to read the config file settings for the serial ports
    EITPortConfig = null;
    BridgePortConfig = null;

    try
    {
        EITPortConfig = (SerialConfigSection)config.GetSection("EITCOMPort");
        BridgePortConfig = (SerialConfigSection)config.GetSection("BridgeCOMPort");

        // Synchronize the application configuration
        // if needed. The following two steps seem
        // to solve some out of synch issues
        // between roaming and default
        // configuration.
        config.Save(ConfigurationSaveMode.Modified);

        // Force a reload of the changed section,
        // if needed. This makes the new values available
        // for reading.
        ConfigurationManager.RefreshSection("EITCOMPort");
        ConfigurationManager.RefreshSection("BridgeCOMPort");

        // If we couldn't retrieve the EITPort section from the config
        if (EITPortConfig == null)
        {
            EITPortConfig = new SerialConfigSection();

            // Define where in the configuration file
            // hierarchy the associated
            // configuration section can be declared.
            // The following assignment assures that
            // the configuration information can be
            // defined in the user.config file in the
            // roaming user directory.
            EITPortConfig.SectionInformation.AllowExeDefinition =
              ConfigurationAllowExeDefinition.MachineToLocalUser;

            // Allow the configuration section to be
            // overridden by lower-level configuration files.
            // This means that lower-level files can contain
            // the section (use the same name) and assign
            // different values to it.
            EITPortConfig.SectionInformation.AllowOverride = true;

            // Add configuration information to
            // the configuration file.
            config.Sections.Add("EITCOMPort", EITPortConfig);
            config.Save(ConfigurationSaveMode.Modified);
            // Force a reload of the changed section. This
            // makes the new values available for reading.
            ConfigurationManager.RefreshSection("EITCOMPort");
        }

        // If we couldn't retrieve the EITPort section from the config
        if (BridgePortConfig == null)
        {
            BridgePortConfig = new SerialConfigSection();

            // Define where in the configuration file
            // hierarchy the associated
            // configuration section can be declared.
            // The following assignment assures that
            // the configuration information can be
            // defined in the user.config file in the
            // roaming user directory.
            BridgePortConfig.SectionInformation.AllowExeDefinition =
              ConfigurationAllowExeDefinition.MachineToLocalUser;

            // Allow the configuration section to be
            // overridden by lower-level configuration files.
            // This means that lower-level files can contain
            // the section (use the same name) and assign
            // different values to it.
            BridgePortConfig.SectionInformation.AllowOverride = true;

            // Add configuration information to
            // the configuration file.
            config.Sections.Add("BridgeCOMPort", BridgePortConfig);
            config.Save(ConfigurationSaveMode.Modified);
            // Force a reload of the changed section. This
            // makes the new values available for reading.
            ConfigurationManager.RefreshSection("BridgeCOMPort");
        }

    }
    catch (ConfigurationErrorsException e)
    {
        Console.WriteLine("[Exception error: {0}]", e.ToString());
    }
}

Jaime Olivares wrote:

Hmm, not sure if it will be practical.

Jaime Olivares wrote:

embedding dlls into a single assembly can have some benefits.

Eddy Vluggen wrote:

One could also compile everything into a massive DLL, but that's harder to update (you'd have to replace the entire thing

Jaime Olivares wrote:

At some point, this becomes a mess which is hard to manage.

Jaime Olivares wrote:

I don't want to replace one or two dlls and leave others untouched

Jaime Olivares wrote:

prefereably as a monolithic big component

Jaime Olivares wrote:

I want to have a big single assembly with dozens of functionality groups, but I don't want them to be uploaded into memory until they are really needed.