Application Deployment

using System.Deployment.Application;

public partial class MainForm : Form
{
    public MainForm()
    {
        InitializeComponent();
        CheckForUpdates();
    }

    private void CheckForUpdates()
    {
        // Check if the application is a ClickOnce deployment
        if (ApplicationDeployment.IsNetworkDeployed)
        {
            var currentDeployment = ApplicationDeployment.CurrentDeployment;

            // Check for updates asynchronously
            try
            {
                UpdateCheckInfo updateInfo = currentDeployment.CheckForDetailedUpdate();

                if (updateInfo.UpdateAvailable)
                {
                    DialogResult result = MessageBox.Show("An update is available. Install now?", "Update", MessageBoxButtons.YesNo);
                    if (result == DialogResult.Yes)
                    {
                        // This will download and apply the update, then restart the app.
                        currentDeployment.Update();
                        MessageBox.Show("Update installed! Application will now restart.");
                        Application.Restart();
                    }
                }
            }
            catch (Exception ex)
            {
                MessageBox.Show($"Failed to check for updates: {ex.Message}");
            }
        }
    }
}

// In a Class Library project referenced by the WiX installer
using System;
using Microsoft.Deployment.WindowsInstaller;

namespace MyInstallerCustomActions
{
    public class CustomActions
    {
        [CustomAction]
        public static ActionResult CreateConfigFile(Session session)
        {
            // This code runs during the MSI installation process.
            // The 'session' object provides access to installer properties.
            try
            {
                string targetDir = session["INSTALLFOLDER"];
                string configPath = System.IO.Path.Combine(targetDir, "appsettings.json");

                // Create a default configuration file during installation
                string defaultConfig = "{ \"ConnectionString\": \"Server=localhost;\" }";
                System.IO.File.WriteAllText(configPath, defaultConfig);

                session.Log("Configuration file created successfully.");
                return ActionResult.Success;
            }
            catch (Exception ex)
            {
                session.Log($"Error creating config file: {ex.Message}");
                return ActionResult.Failure;
            }
        }
    }
}

// Program.cs - Using environment-specific configuration
var builder = WebApplication.CreateBuilder(args);

// Web Deploy doesn't touch this code. Its power is in delivering the right appsettings file
// The framework automatically handles merging configurations.
builder.Configuration.AddJsonFile("appsettings.json", optional: false)
                     .AddJsonFile($"appsettings.{builder.Environment.EnvironmentName}.json", optional: true);

// The rest of your app configuration...

<!-- In your .csproj file, you can define a publish profile -->
<Project Sdk="Microsoft.NET.Sdk.Web">
  <PropertyGroup>
    <TargetFramework>net8.0</TargetFramework>
  </PropertyGroup>

  <!-- The build pipeline would call: dotnet publish -c Release -p:PublishProfile=FolderProfile -->
</Project>

# Dockerfile
# 1. Use the SDK image to build the application
FROM mcr.microsoft.com/dotnet/sdk:8.0 AS build
WORKDIR /src
COPY MyAspNetCoreApp.csproj .
RUN dotnet restore
COPY . .
RUN dotnet publish -c Release -o /app

# 2. Use the runtime image to create a small final image
FROM mcr.microsoft.com/dotnet/aspnet:8.0 AS runtime
WORKDIR /app
COPY --from=build /app .
# The container expects to run the DLL on port 80
EXPOSE 80
ENTRYPOINT ["dotnet", "MyAspNetCoreApp.dll"]

using Azure.Identity;
using Azure.ResourceManager;
using Azure.ResourceManager.Resources;
using Azure.ResourceManager.AppService;

// Authenticate using DefaultAzureCredential (works in VS, Azure CLI, Managed Identity)
var armClient = new ArmClient(new DefaultAzureCredential());

// Get the subscription and resource group
SubscriptionResource subscription = await armClient.GetDefaultSubscriptionAsync();
ResourceGroupResource resourceGroup = await subscription.GetResourceGroupAsync("my-resource-group");

// Define the web app properties
var webAppData = new WebSiteData(AzureLocation.WestUS2)
{
    SiteConfig = new SiteConfigProperties
    {
        NetFrameworkVersion = "v8.0", // For .NET 8
        IsAlwaysOn = true
    }
};

// Create the web app resource
var webAppCollection = resourceGroup.GetWebSites();
var webAppOperation = await webAppCollection.CreateOrUpdateAsync(
    WaitUntil.Completed,
    "my-unique-app-name",
    webAppData
);

Console.WriteLine($"App deployed at: {webAppOperation.Value.Data.DefaultHostName}");

var builder = WebApplication.CreateBuilder(args);

// 1. Built-in support for JSON files and environment variables
builder.Configuration.AddJsonFile("appsettings.json");
builder.Configuration.AddEnvironmentVariables();

// 2. Advanced: Add Azure Key Vault for secrets
builder.Configuration.AddAzureKeyVault(
    new Uri($"https://{builder.Configuration["KeyVaultName"]}.vault.azure.net/"),
    new DefaultAzureCredential()
);

// 3. Access configuration values throughout the app
var connectionString = builder.Configuration.GetConnectionString("Database");
var featureFlag = builder.Configuration.GetValue<bool>("FeatureFlags:NewUi");

// Registering a service with configuration
builder.Services.AddDbContext<MyDbContext>(options =>
    options.UseSqlServer(connectionString));