notes.txt

using System;
using System.Collections.Generic;
using System.Text;
using System.IO;
using Microsoft.Build.Framework;
using Microsoft.Build.Utilities;

namespace MSBuildLibrary
{

    //https://github.com/dotnet/samples/blob/main/msbuild/custom-task-code-generation/MSBuildConsoleExample/MSBuildConsoleExample.sln

    public class AppSettingStronglyTyped : Microsoft.Build.Utilities.Task
    {
        //The name of the class which is going to be generated
        [Required]
        public string SettingClassName { get; set; }

        //The name of the namespace where the class is going to be generated
        [Required]
        public string SettingNamespaceName { get; set; }

        //List of files which we need to read with the defined format: 'propertyName:type:defaultValue' per line
        [Required]
        public ITaskItem[] SettingFiles { get; set; }

        // The filename where the class was generated
        [Output]
        public string ClassNameFile { get; set; }

        public override bool Execute()
        {
            //Read the input files and return a IDictionary<string, object> with the properties to be created.
            //Any format error it will return false and log an error
            var (success, settings) = ReadProjectSettingFiles();
            if (!success)
            {
                return !Log.HasLoggedErrors;
            }
            //Create the class based on the Dictionary
            success = CreateSettingClass(settings);

            return !Log.HasLoggedErrors;
        }

        private (bool, IDictionary<string, object>) ReadProjectSettingFiles()
        {
            var values = new Dictionary<string, object>();
            foreach (var item in SettingFiles)
            {
                int lineNumber = 0;

                var settingFile = item.GetMetadata("FullPath");
                foreach (string line in File.ReadLines(settingFile))
                {
                    lineNumber++;

                    var lineParse = line.Split(':');
                    if (lineParse.Length != 3)
                    {
                        Log.LogError(subcategory: null,
                                     errorCode: "APPS0001",
                                     helpKeyword: null,
                                     file: settingFile,
                                     lineNumber: lineNumber,
                                     columnNumber: 0,
                                     endLineNumber: 0,
                                     endColumnNumber: 0,
                                     message: "Incorrect line format. Valid format prop:type:defaultvalue");
                        return (false, null);
                    }
                    var value = GetValue(lineParse[1], lineParse[2]);
                    if (!value.Item1)
                    {
                        return (value.Item1, null);
                    }

                    values[lineParse[0]] = value.Item2;
                }
            }
            return (true, values);
        }

        private (bool, object) GetValue(string type, string value)
        {
            try
            {
                // So far only few types are supported values.
                if ("string".Equals(type))
                {
                    return (true, value);
                }
                if ("int".Equals(type))
                {
                    return (true, int.Parse(value));
                }
                if ("long".Equals(type))
                {
                    return (true, long.Parse(value));
                }
                if ("guid".Equals(type))
                {
                    return (true, Guid.Parse(value));
                }
                if ("bool".Equals(type))
                {
                    return (true, bool.Parse(value));
                }
                Log.LogError($"Type not supported -> {type}");
                return (false, null);
            }
            catch
            {
                Log.LogError($"It is not possible parse some value based on the type -> {type} - {value}");
                return (false, null);
            }
        }

        private bool CreateSettingClass(IDictionary<string, object> settings)
        {
            try
            {
                ClassNameFile = $"{SettingClassName}.generated.cs";
                File.Delete(ClassNameFile);
                StringBuilder settingsClass = new StringBuilder(1024);
                // open namespace
                settingsClass.Append($@" using System;
 namespace {SettingNamespaceName} {{

  public class {SettingClassName} {{
");
                //For each element in the dictionary create a static property
                foreach (var keyValuePair in settings)
                {
                    string typeName = GetTypeString(keyValuePair.Value.GetType().Name);
                    settingsClass.Append($"    public readonly static {typeName}  {keyValuePair.Key} = {GetValueString(keyValuePair, typeName)};\r\n");
                }
                // close namespace and class
                settingsClass.Append(@"  }

}");
                File.WriteAllText(ClassNameFile, settingsClass.ToString());

            }
            catch (Exception ex)
            {
                //This logging helper method is designed to capture and display information from arbitrary exceptions in a standard way.
                Log.LogErrorFromException(ex, showStackTrace: true);
                return false;
            }
            return true;
        }

        private string GetTypeString(string typeName)
        {
            if ("String".Equals(typeName))
            {
                return "string";
            }
            if ("Boolean".Equals(typeName))
            {
                return "bool";
            }
            if ("Int32".Equals(typeName))
            {
                return "int";
            }
            if ("Int64".Equals(typeName))
            {
                return "long";
            }
            return typeName;
        }

        private static object GetValueString(KeyValuePair<string, object> keyValuePair, string typeName)
        {
            if ("Guid".Equals(typeName))
            {
                return $"Guid.Parse(\"{keyValuePair.Value}\")";
            }
            if ("string".Equals(typeName))
            {
                return $"\"{keyValuePair.Value}\"";
            }
            if ("bool".Equals(typeName))
            {
                return $"{keyValuePair.Value.ToString().ToLower()}";
            }

            return keyValuePair.Value;
        }
    }
}

  /*
     	<UsingTask TaskName="FooTask" AssemblyFile="$(MSBuildThisFileDirectory)$(OutputPath)MSBuildLibrary35.dll"/>

	    <Target Name="FooTaskTarget" AfterTargets="Build">
		    <FooTask Parameter1="abc">
			    <Output TaskParameter="Result1" PropertyName="SettingClassFileName" />
		    </FooTask>
		    <Message Text="Hello foo $(SettingClassFileName)" Importance="high" />
	    </Target>
    */

    //https://learn.microsoft.com/en-us/visualstudio/msbuild/task-writing?view=vs-2022

/*

    public class MyTask : Microsoft.Build.Utilities.Task
    {
        // The filename where the class was generated
        [Output]
        public string Result1 { get; set; }

        public override bool Execute()
        {
            string currentProjectPath = this.BuildEngine.ProjectFileOfTaskNode;
            var projectCollection = new ProjectCollection();
            var project = new Project(currentProjectPath, null, null, projectCollection);

            // Log some project properties
            Log.LogMessage(MessageImportance.High, $"Project File: {currentProjectPath}");
            Log.LogMessage(MessageImportance.High, $"Target Framework: {project.GetPropertyValue("TargetFramework")}");
            Log.LogMessage(MessageImportance.High, $"Output Path: {project.GetPropertyValue("OutputPath")}");
            project.SetProperty("foox", "fooxvalue");
            project.SetGlobalProperty("far", "far");
            this.Result1 = project.GetPropertyValue("TargetFramework");
            return true;
        }
    }

    public class CollectPropertiesTask : Microsoft.Build.Utilities.Task
    {
        [Output]
        public ITaskItem[] AllProperties { get; set; }

        public override bool Execute()
        {
            var properties = new List<ITaskItem>();

            Project project = new Project(BuildEngine.ProjectFileOfTaskNode);

            foreach (var item in project.GlobalProperties)
            {
                //Log.LogMessage(MessageImportance.High, $@"sssssssss {item.Key}");
            }

 
            if (project != null)
            {
                foreach (var prop in project.AllEvaluatedProperties)
                {
                    var taskItem = new TaskItem(prop.Name);
                    taskItem.SetMetadata("Value", prop.EvaluatedValue);
                    properties.Add(taskItem);
                }
            }

            project.Save(@"C:\temp\cc.csproj");

            AllProperties = properties.ToArray();
            return true;
        }
    }

    
    <!-- 
    <ItemGroup>
        <PackageReference Include="Microsoft.Build" Version="15.9.20" />
        <PackageReference Include="Microsoft.Build.Utilities.Core" Version="15.9.20" />
    </ItemGroup>

	<Target Name = "out" AfterTargets="Build">
		<Message Text = "out: $(MSBuildThisFileDirectory)MSBuildLibrary35.dll" Importance="high" />
	</Target>

	<UsingTask TaskName = "FooTask" AssemblyFile="$(MSBuildThisFileDirectory)$(OutputPath)MSBuildLibrary35.dll"/>
	<UsingTask TaskName = "SimpleTask" AssemblyFile="$(MSBuildThisFileDirectory)$(OutputPath)MSBuildLibrary35.dll"/>
	<UsingTask TaskName = "MyTask" AssemblyFile="$(MSBuildThisFileDirectory)$(OutputPath)MSBuildLibrary35.dll"/>
	<UsingTask TaskName = "CollectPropertiesTask" AssemblyFile="$(MSBuildThisFileDirectory)$(OutputPath)MSBuildLibrary35.dll"/>

	<Target Name = "FooTaskTarget" AfterTargets="Build">
		<FooTask Parameter1 = "abc">

            <Output TaskParameter="Result1" PropertyName="SettingClassFileName" />
		</FooTask>
		
		<Message Text = "Hello foo $(SettingClassFileName)" Importance="high" />
	</Target>

	<Target Name = "UseSimpleTask" AfterTargets="Build">
		<SimpleTask/>
	</Target>

	<Target Name = "UseMyTask" AfterTargets="Build">
		<MyTask><Output TaskParameter = "Result1" PropertyName="SetMe" /></MyTask>
		<Message Text = "SetMe: $(SetMe)" Importance="high" />
	</Target>

	<Target Name = "UseCollectPropertiesTask" AfterTargets="Build">
		<CollectPropertiesTask>
			<Output TaskParameter = "AllProperties" ItemName="CapturedProperties" />
		</CollectPropertiesTask>

		<Message Text = "%(CapturedProperties.Identity) = %(CapturedProperties.Value)" Importance="high"/>
	</Target>

	<Target Name = "CustomAfterBuildTarget" AfterTargets="Build">
		<Message Text = "Hello from CustomAfterBuildTarget" Importance="high" />
		<Message Text = "MSBuildThisFile:                $(MSBuildThisFile)" Importance="high" />
		<Message Text = "MSBuildThisFileDirectory:       $(MSBuildThisFileDirectory)" Importance="high" />
		<Message Text = "MSBuildThisFileDirectoryNoRoot: $(MSBuildThisFileDirectoryNoRoot)" Importance="high" />
		<Message Text = "MSBuildThisFileExtension:       $(MSBuildThisFileExtension)" Importance="high" />
		<Message Text = "MSBuildThisFileFullPath:        $(MSBuildThisFileFullPath)" Importance="high" />
		<Message Text = "MSBuildThisFileName:            $(MSBuildThisFileName)" Importance="high" />

		<Message Text = "BinFolder:						$(BinFolder)" Importance="high" />
		<Message Text = "DestinationFolder:				$(DestinationFolder)" Importance="high" />
		<Message Text = "OutDir:							$(OutDir)" Importance="high" />
		<Message Text = "OutputPath:						$(OutputPath)" Importance="high" />
		<Message Text = "BaseOutputPath:					$(BaseOutputPath)" Importance="high" />
		<Message Text = "PublishDir:						$(PublishDir)" Importance="high" />

	</Target>
-->	
    */

    	<Target Name = "debugout" AfterTargets="Build">
		<Message Text = "Hello from CustomAfterBuildTarget" Importance="high" />
		<Message Text = "MSBuildThisFile:                   $(MSBuildThisFile)" Importance="high" />
		<Message Text = "MSBuildThisFileDirectory:          $(MSBuildThisFileDirectory)" Importance="high" />
		<Message Text = "MSBuildThisFileDirectoryNoRoot:    $(MSBuildThisFileDirectoryNoRoot)" Importance="high" />
		<Message Text = "MSBuildThisFileExtension:          $(MSBuildThisFileExtension)" Importance="high" />
        <Message Text = "MSBuildThisFileFullPath:           $(MSBuildThisFileFullPath)" Importance="high" />
		<Message Text = "MSBuildThisFileName:               $(MSBuildThisFileName)" Importance="high" />

		<Message Text = "BinFolder:						$(BinFolder)" Importance="high" />
		<Message Text = "DestinationFolder:				$(DestinationFolder)" Importance="high" />
		<Message Text = "OutDir:						$(OutDir)" Importance="high" />
		<Message Text = "OutputPath:					$(OutputPath)" Importance="high" />
		<Message Text = "BaseOutputPath:				$(BaseOutputPath)" Importance="high" />
		<Message Text = "PublishDir:					$(PublishDir)" Importance="high" />

	</Target>
    Benchmark.NET
Terminal.GUI
WPFUI
LINQKit
MediatR
Polly
NodaTime
HangFire
Serilog
NLOG
Refit
Apizr
FluentValidation
log4net
FluentAssertions
NSubstitute
Dapper
Flurl
ManyConsole
Humanizer.Core
AutoMapper
Quartz.NET
NAudio
CsvHelper
Spectre.Console
coverlet.collector 

in src:
dotnet pack -c Debug
dotnet new install Projects\Coree.Template.Project\bin\Package\Coree.Template.Project.0.2.8934.6807-local.nupkg