.NET (Core and Framework)

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.

Mark Nischalke wrote:

How large will this single assembly be? How large will it grow?

Mark Nischalke wrote:

If only one method in one class gets updated you have to recompile and distribute the entire assembly?

Jaime Olivares wrote:

Application can be about 10-20 MB executable

Jaime Olivares wrote:

releases are frequent

Jaime Olivares wrote:

Updating just some components is always a risk and produces potential branching problem.

Jaime Olivares wrote:

A different combination of components is used depending on specific product.

Jaime Olivares wrote:

So my intention is to release always the entire suite of components, prefereably in a single assembly.