Knowledge Base for IT Professionals, Teachers and Astronauts
The C# Setup.msi installer can take an argument, TARGETDIR to set the install location of the application.
msiexec.exe /i "Setup.msi" /qn /norestart TARGETDIR="D:\MY_APP_DIRECTORY"If the application is already installed on the computer, and we try to change the install location without first uninstalling it, the installer ignores the value in the TARGETDIR property.
To be able to install the application at a new location, first uninstall the application and run the Setup.msi again.
Windows scheduled tasks are used to automatically execute processes on a set schedule.
To allow a long running process to continue, even if the scheduled task would start it again before the process completion, we need to uncheck the “If the running task does not end when requested, force it to stop” option.
When we use PowerShell to create the scheduled task, in the New-ScheduledTaskSettingsSet command use the -DisallowHardTerminate option.
$settings = New-ScheduledTaskSettingsSet `
-AllowStartIfOnBatteries `
-DontStopIfGoingOnBatteries `
-StartWhenAvailable `
-RunOnlyIfNetworkAvailable:$false `
-ExecutionTimeLimit (New-TimeSpan -Hours 12) `
-MultipleInstances IgnoreNew `
-DisallowHardTerminateTo be able to create, edit, and test MSSQL SSIS package solutions in Visual Studio Community edition we need to install the SQL Server Data Tools under Data storage and processing in the list of workloads.
See Integration Services (SSIS) Projects and Solutions for more information
When a C# project moved from an earlier version of Visual Studio to Visual Studio 2022, AOT (Ahead Of Time) publish starts to fail with the error message
RuntimeIdentifier is required for native compilation. Try running dotnet publish with the -r option value specified.
This is cuased by old settings in the project. To eliminate the problem
<Import Project="$(MSBuildThisFileDirectory)Microsoft.NETCore.Native.Publish.targets" Condition="'$(NativeCompilationDuringPublish)' != 'false'" />
To use command line arguments during debugging in Visual Studio Community Edition we will create project profiles.
To debug the application with a specific project profile
Visual Studio Community Edition is a free, popular IDE to develop C# business applications. AI assistance can enhance the development process and do the boilerplate creation.
As of writing, the most popular free extension that supports multiple AI models is Comment2GPT by Merry Yellow.
For more information visit the Comment2GPT Visual Studio Marketplace page at Comment2GPT
This extension supports multiple AI models, so we can select the best for our purpose, or the one that is allowed on by our company.
To use Gemini in Commenct2GPT, we need to create a free Google Gemini API key.
For the list of Gemini model versions and IDs visit Gemini models. We will need the ID of the model to configure Comment2GPT.
For our example we will use the Gemini 2.5 Flash Preview 05-20 model with the ID: gemini-2.5-flash-preview-05-20 model as it provides free, balanced performance. Currently, the free tier allows 10 requests per minute (RPM), 250,000 tokens per minute (TPM) and 500 requests per day (RPD). This should be enough for software development.
Before you start to configure Comment2GPT, get the ID of the latest model you want to use.
| Page | URL |
| List of models to get the the model ID | Gemini models |
| Pricing | Gemini Developer API Pricing |
| Rate limits | Rate limits |
| Billing info | Billing |
To ask Comment2GPT to generate code for you
// gpt write a function to retrieve aws canary results from cloudwatchOn the Comment2GPT Request tab the Instruction message fields contain long explanation for the model to process the Add, Chant, Complete and Edit requests. Copy the contents to a text editor to view the entire text. Very interesting read.
It is interesting, two identical requests generated entirely different results, one with 65 lines, the second with 196 lines of code.
When the .NET Entity Framework retrieves data from the database and parses it into the structure that we specify in our code, we have to make sure nullable columns are modeled with nullable properties in our code.
When null values are retrieved and the structure in the code does not allow null value in any property, we get the System.Data.SqlTypes.SqlNullValueException exception
Data is Null. This method or property cannot be called on Null values.
Make sure all nullable columns are modeled with nullable properties.
CREATE TABLE [dbo].[task](
[id] [int] IDENTITY(1,1) NOT NULL,
[filenames] [nvarchar](max) NULL,
[source_path] [nvarchar](255) NULL,
[target_path] [nvarchar](255) NULL
public class task
{
public int id { get; set; }
public string? filenames { get; set; }
public string? source_path { get; set; }
public string? target_path { get; set; }
}Standalone Windows executables are compiled ahead of time (AOT) and distributed as three executable files (.exe, .dll, .runtimeconfig.json). This format is ideal for small executables called from the command line or from other applications.
To create an AOT Windows executable in Visual Studio 2022 or later
// See https://aka.ms/new-console-template for more information
Console.WriteLine("Test executable started");
// Read the command line arguments into an array
string[] arguments = args;
Console.WriteLine($"Number of command line arguments {arguments.Length}");
if (arguments != null && arguments.Length > 0)
{
var firstArgument = arguments[0];
Console.WriteLine($"First argument = {firstArgument}");
if (firstArgument == "ERROR" )
{
Console.WriteLine("Throw divide by zero exception");
int a = 0;
int b = 1 / a;
}
}
Console.WriteLine("Test executable exited without error"); To be able to build, link and publish the standalone executable we need to install the “Desktop development with C++” Visual Studio workload.
By default the output is placed in the bin\Debug\net8.0 directory
To run the (not really) “standalone” application, we need the following three files in the same directory:
See Visual Studio Installer Projects Extension and .NET on creating a Setup project
See RuntimeIdentifier is required for native compilation. Try running dotnet publish with the -r option value specified. in case you get this error during publishing.
In this post we will develop a .NET 8 console application which reads the configuration values from environment variables. This enables us deploy the application in an EKS cluster and read the config values from any secure secret storage.
Debugging in Docker containers provides a stable, production like environment for your application, but larger applications can take a long time to build into containers. To stop Visual Studio debugging in Docker containers see Prevent Visual Studio 2022 from debugging in Docker. Official documentation is at Project warmup.
If you want to debug in Docker containers to see how your application will run in production
To be able to start Docker Desktop on Windows your user id has to be in the docker-users local user group. To add your user to the group
whoamiAdd the user to the docker-users user group:
net localgroup docker-users "your-user-id" /ADDLog out and log in into Windows for the change to take effect.
If Docker Desktop recommends using WSL instead of Hyper-V and WSL is not installed on your computer
Enable-WindowsOptionalFeature -Online -FeatureName $("VirtualMachinePlatform", "Microsoft-Windows-Subsystem-Linux")Restart the computer for the change to take effect.
You may need to install and enable the WSL2 Linux kernel. See Step 4 – Download the Linux kernel update package for details. Don’t forget to activate the WSL2 kernel with
wsl --set-default-version 2IMPORTANT!!!
To exclude the .env file and other temporary and build files from the Git commit create the .gitignore file
dotnet new gitignoregit initEnvironment variables are the safest and most flexible way to store sensitive configuration values. This way those are never committed to source control.
To be able to access environment variables we need to install the following NuGet packages
To install the packages from the command line, open a terminal in the project directory and execute
dotnet add package DotNetEnv
dotnet add package Microsoft.Extensions.Configuration.EnvironmentVariablesCreate the .env file in the solution directory and add a key value pair
ENVIRONMENT=localCreate the Settings.cs class to store the configuration values
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace MY_NAMESPACE
{
internal class Settings
{
public string? Environment { get; set; }
public string? AppName { get; set; }
}
public class ConnectionStrings
{
public string? SQLServer { get; set; }
}
}
Create the Configuration.cs class to read the configuration values form the environment variables
using DotNetEnv;
using Microsoft.Extensions.Configuration;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace MY_NAMESPACE
{
internal class Configuration
{
/// <summary>
/// Reads the config values from the environment variables and returns the Settings object
/// </summary>
/// <returns></returns>
public static Settings BuildAppSettings()
{
// Try to load the environment variables from the .env file for local development
// Place the .env file in the root folder of the solution
DotNetEnv.Env.TraversePath().Load();
// Read the environment variables
var environmentConfiguration = new ConfigurationBuilder()
.AddEnvironmentVariables().Build();
// Instantiate and populate the Settings object
var settings = new Settings()
{
Environment = environmentConfiguration["ENVIRONMENT"],
AppName = environmentConfiguration["APPNAME"]
};
// Return the Settings object
return settings;
}
}
}
In the Program.cs file call Configuration to load the Settings object from the environment variables.
// See https://aka.ms/new-console-template for more information
using MY_APPLICATION;
using DotNetEnv;
using Microsoft.Extensions.Configuration;
// args is a string array that contains the command line arguments
string[] arguments = args;
Console.WriteLine($"Number of command line arguments {arguments.Length}");
// Read the configuration values
Settings settings = Configuration.BuildAppSettings();
Console.WriteLine($"Envronment: {settings.Environment}");
Console.WriteLine($"AppName: {settings.AppName}");
Visual Studio Community Edition has all the features for MSSQL SSIS package development. We need to download the SQL Server Integration Services Projects extension.
In the package properties set DelayValidation to True to avoid long wait when opening the package.