A Programmer with Microsoft tools

RSCG – EntityLengths.Generator

name	EntityLengths.Generator
nuget	https://www.nuget.org/packages/EntityLengths.Generator/
link	https://github.com/TarasKovalenko/EntityLengths.Generator/
author	Taras Kovalenko

Generating constants for max length for properties in entities

This is how you can use EntityLengths.Generator .

The code that you start with is


<Project Sdk="Microsoft.NET.Sdk">

  <PropertyGroup>
    <OutputType>Exe</OutputType>
    <TargetFramework>net9.0</TargetFramework>
    <ImplicitUsings>enable</ImplicitUsings>
    <Nullable>enable</Nullable>
  </PropertyGroup>
	<ItemGroup>
		<PackageReference Include="Microsoft.EntityFrameworkCore.InMemory" Version="9.0.1" />
		<PackageReference Include="Microsoft.EntityFrameworkCore.Design" Version="9.0.1">
		</PackageReference>
		<PackageReference Include="Microsoft.EntityFrameworkCore" Version="9.0.1" />
		<PackageReference Include="EntityLengths.Generator" Version="1.0.3" />

	</ItemGroup>
	<PropertyGroup>
		<EmitCompilerGeneratedFiles>true</EmitCompilerGeneratedFiles>
		<CompilerGeneratedFilesOutputPath>$(BaseIntermediateOutputPath)\GX</CompilerGeneratedFilesOutputPath>
	</PropertyGroup>
</Project>

The code that you will use is


Console.WriteLine("Hello, World!");
DbContextOptionsBuilder<DotNetStatsContext> optionsBuilder = new();
optionsBuilder.UseInMemoryDatabase("StatsDatabase");
var cnt = new DotNetStatsContext(optionsBuilder.Options);
await cnt.Database.EnsureCreatedAsync();
Console.WriteLine("Database created");
Console.WriteLine(cnt.Projects.Count());
Console.WriteLine("The max length of the Name property of the Project entity is: " + Constants.Project.NameLength);


global using Microsoft.EntityFrameworkCore;
global using Stats.Database;
using EntityLengths.Generator.Configuration;

[assembly: EntityLengthsGenerator(
    GenerateDocumentation = false,
    GeneratedClassName = "Constants",
    LengthSuffix = "Length",
    IncludeNamespaces = ["Stats.Database"],
    ExcludeNamespaces = [],
    ScanNestedNamespaces = true,
    ScanEntitySuffix = null,
    Namespace = "Stats.Database"
)]



namespace Stats.Database;
public partial class DotNetStatsContext : DbContext
{
    internal DotNetStatsContext() : base() { }
    public DotNetStatsContext(DbContextOptions<DotNetStatsContext> options)
        : base(options)
    {
        
    }
    
    public virtual DbSet<Project> Projects { get; set; }

    public virtual DbSet<Star> Stars { get; set; }

    protected override void OnModelCreating(ModelBuilder modelBuilder)
    {
        modelBuilder.Entity<Project>(entity =>
        {
            entity.ToTable("Project");

            entity.Property(e => e.Id).HasColumnName("ID");
            entity.Property(e => e.Description).HasMaxLength(500);
            entity.Property(e => e.Name).HasMaxLength(50);
            entity.Property(e => e.SourceCodeUrl).HasMaxLength(50);
        });

        modelBuilder.Entity<Star>(entity =>
        {
            entity.Property(e => e.Id)
                .HasColumnName("ID");
            entity.Property(e => e.Idproject).HasColumnName("IDProject");
        });

        OnModelCreatingPartial(modelBuilder);
    }

    partial void OnModelCreatingPartial(ModelBuilder modelBuilder);
}

The code that is generated is

// <auto-generated/>
namespace Stats.Database;

public static partial class Constants 
{
	public static partial class Project
	{
		public const int DescriptionLength = 500;
		public const int NameLength = 50;
		public const int SourceCodeUrlLength = 50;
	}
}

Code and pdf at

https://ignatandrei.github.io/RSCG_Examples/v2/docs/EntityLengths.Generator

What I have learned by building .NET Stars -part 5 – always available data for a display website

Dotnet Stars being a site just for displaying data, it does not require an API per se. Yes, for development purposes it needs a database and an API to display – but later – the data could be retrieved from local.

The first part is to write data in JSON files near to Blazor . But how to export by default this ?

And here ASPIRE thrives : I have made a console app to export data – and registered in ASPIRE with dependency of Blazor – and can see where Blazor folder is.

this is the extension

public static IResourceBuilder<TRes> AddPathToEnvironmment<TProject,TRes>(
        this IResourceBuilder<TRes> builder, TProject p, string name)
        where TProject : IProjectMetadata, new()
        where TRes : IResourceWithEnvironment            
{
    //var p = new TProject();        
    string pathPrj = p.ProjectPath;
    var fi = new FileInfo(pathPrj);
    string dirName = fi?.DirectoryName ?? "";
    var projectBuilder = builder
        .WithEnvironment(ctx=>
        {
            ctx.EnvironmentVariables[name] =dirName;
            ctx.EnvironmentVariables[$"{name}csproj"] = pathPrj;
        });

    return projectBuilder;
}

and this is how it is used

var exportToJson = builder.AddProject<Projects.StatsExport>("statsExport")
    .WithReference(ui)    
    .WithReference(db)
    .WaitFor(db)
    .AddPathToEnvironmment(new Projects.StatsBlazorUI(),"pathToWrite")
    ;

And the code that uses this

var pathToWrite = Environment.GetEnvironmentVariable("pathToWrite");
if (string.IsNullOrWhiteSpace(pathToWrite))
{
    Console.WriteLine("please add a path to write");
    return;
}

The second part is to get data from WebAPI , if available, and, if not, from JSON files.
And here the Roslyn Code Generator, https://github.com/ignatandrei/RSCG_CompositeProvider , it is useful .
We have 2 implementations of same interface ,

public interface IStatsData
{
   //other code
    IAsyncEnumerable<IProjectWithStars> GetProjectsWithStars();
}

And we have an implementation from WebAPI and another from JSON files

With the nugethttps://nuget.org/packages/RSCG_CompositeProviderwe can obtain data from the first that returns data.

builder.Services.AddKeyedScoped<IStatsData>("both", (sp, obj) =>
{
    var statsDataLocal = sp.GetRequiredKeyedService<IStatsData>("local_host");
    var statsDataAPI = sp.GetRequiredKeyedService<IStatsData>("statsconsole_host");
    StatsData_CP composite = new(statsDataAPI, statsDataLocal);
    composite.UseFirstTheLastOneThatWorks = true;
    return composite;
});

RSCG-Composite Provider – part 2 -execution

Imagine this: For every interface IA you create:

Your composite provider implements IA seamlessly
In the constructor, pass an array of IA providers
Each method returns the first successful value from your array of providers
For even better performance, use a boolean flag to optimize by reusing previous successes

The RSCG_CompositeProvider package doesnΓÇÖt just solve the obvious issuesΓÇöit handles the tricky ones too:

Exception Handling: What if one of your providers throws an error? No worries, it moves on to the next provider without skipping a beat.
Asynchronous Methods: Supports `Task` returns so you can handle async operations with ease.
Async Enumerables: Easily works with `IAsyncEnumerable` for streaming data in chunks.

I will let you think how to solve this – you can find my solution at https://github.com/ignatandrei/RSCG_CompositeProvider

And the best news? It’s already been tested: with over 20 tests covering every edge case, you can trust this library to handle your toughest challenges.

Get started with RSCG-Composite Provider, available via NuGet: http://nuget.org/packages/RSCG_CompositeProvider.

{ADCES] Discutii si Networking

Timp de discutii / networking / profesional / neprofesional.

Va invitam pe toti

Atentie : schimbam locatia la Restaurant Vanity

https://maps.app.goo.gl/JdEWeykHCHN91Mjs6

RSCG-Composite Provider – part 1 -idea

API Outage solved with local data

The problem that I try to solve is : How an UI can have data to show , even if the API from where it gathers data does not work ?

Imagine having a robust system that adaptively switches between retrieving data from multiple sources – including internal APIs, memory-based storage, or even JSON files near the UI. This flexibility makes all the difference when working with complex systems that may suddenly lose their external connectivity.

This could be solved with interfaces and a composite provider ( see http://msprogrammer.serviciipeweb.ro/2025/03/10/pattern-compositeprovider/ )

How It Works:

You have an interface defining how your UI fetches data.Easy peasy!
One implementation pulls data from the trusty API, ideally when it’s up and running smoothly.
Another implementation acts as a backup hero, pulling data from a local JSON file or even hard-coded values.

And the best part? The composite provider handles switching between these sources seamlessly. No more coding headaches – it just works!

Making It Even Easier: Roslyn Code Generator to the Rescue

Tired of writing boilerplate code for this pattern every time? Please give a chance to a new Roslyn Code Generator (https://www.nuget.org/packages/RSCG_CompositeProvider). It automatically generates the composite providers you need, cutting down on repetitive work and letting you focus on what really matters – building awesome apps!

Friday links 503

Global AI Bootcamp Bucarest

The presentation for Global AI Bootcamp Bucarest https://www.meetup.com/bucharest-a-d-c-e-s-meetup/events/305949555/

From Vlad Iliescu

https://github.com/vladiliescu/talk-agents-agents-agents

From Daniel Costea
https://docs.google.com/presentation/d/1AD0mE_otKot_WTGUcYrGZO25yHzuDXEvKNT0lXueN9M/edit?usp=sharing

From me

https://ignatandrei.github.io/Presentations/GenAIScriptprez.html#/

RSCG – RSCG_CompositeProvider

name	RSCG_CompositeProvider
nuget	https://www.nuget.org/packages/RSCG_CompositeProvider/ https://www.nuget.org/packages/RSCG_CompositeProvider_common/
link	https://github.com/ignatandrei/RSCG_CompositeProvider
author	Ignat Andrei

Generate composite class from interface, using multiple sources

This is how you can use RSCG_CompositeProvider .

The code that you start with is


<Project Sdk="Microsoft.NET.Sdk">

  <PropertyGroup>
    <OutputType>Exe</OutputType>
    <TargetFramework>net9.0</TargetFramework>
    <ImplicitUsings>enable</ImplicitUsings>
    <Nullable>enable</Nullable>
	  <IsPackable>false</IsPackable>
  <TreatWarningsAsErrors>true</TreatWarningsAsErrors>
</PropertyGroup>

  
  <ItemGroup>
    <PackageReference Include="RSCG_CompositeProvider" Version="2025.218.2100" OutputItemType="Analyzer" ReferenceOutputAssembly="false" />
    <PackageReference Include="RSCG_CompositeProvider_Common" Version="2025.218.2100" />
  </ItemGroup>
  <PropertyGroup>
		<EmitCompilerGeneratedFiles>true</EmitCompilerGeneratedFiles>
		<CompilerGeneratedFilesOutputPath>$(BaseIntermediateOutputPath)\GX</CompilerGeneratedFilesOutputPath>
	</PropertyGroup>
</Project>

The code that you will use is


using CP_Console;

IDataValue provider = new DataValue_CP(new DataFromHttp(), new DataFromMemory());
var result = await provider.KeyFromValue("test", false);
Console.WriteLine(result);
DataValue_CP realClass = (DataValue_CP)provider ;
var lastInterface = realClass.lastUsedInterface ?? -1;
Console.WriteLine("value was obtained from " + realClass.Get(lastInterface).Name);


using RSCG_CompositeProvider_Common;

namespace CP_Console;
[CompositeProvider]
public interface IDataValue
{
    public string Name { get; set; }
    public Task<string> KeyFromValue(string key, bool defaultValue);

    
}



namespace CP_Console;

class DataFromHttp : IDataValue
{
    public string Name { get { return "DataFromHttp"; } set { } }

    public async Task<string> KeyFromValue(string key, bool defaultValue)
    {
        var http=new HttpClient();
        var result = await http.GetStringAsync("https://www."+ Guid.NewGuid().ToString()+".com/" + key);
        return result;
    }
}


class DataFromMemory : IDataValue
{
    public string Name { get { return "DataFromMemory"; } set { } }

    public async Task<string> KeyFromValue(string key, bool defaultValue)
    {
        await Task.Delay(1000);
        return $"this is value for {key} from memory";
    }
}

The code that is generated is


                // <auto-generated/>
                namespace Generated.CP_Console
                {
                    public static class TheAssemblyInfo
                    {
                        
                        public static readonly System.DateTime DateGeneratedUTC ;
                        public const string AssemblyName = "CP_Console";
                        public const string GeneratedNameNice = "Bertrand Russell is feeling good-natured in Rothera";
                        public const string GeneratedNameSmall = "good-natured-Bertrand Russell";
                        public const string GeneratedName = "good-natured-Bertrand Russell-Rothera";
                        static TheAssemblyInfo(){
                            DateGeneratedUTC = System.DateTime.ParseExact("2025-02-24 14:32:51", "yyyy-MM-dd HH:mm:ss", null);
                        }
                    }
                }

// <auto-generated>
    //     This code was generated by a tool :RSCG_CompositeProvider
    //     Runtime Version: Herta Müller is feeling amiable in George Town
    //     DateOfTool : 2025-02-18 17:23:31
    //     Changes to this file may cause incorrect behavior and will be lost if
    //     the code is regenerated.
    //</auto-generated>
//------------------------------------------------------------------------------
/// <summary>
    /// This static partial class is a composite provider of IDataValue objects. 
    ///</summary>

#nullable enable
#pragma warning disable CS8603
#pragma warning disable CS8625
[global::System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverage]
[global::System.CodeDom.Compiler.GeneratedCode("GeneratorName","2025.10218.11723.131")]
[System.Diagnostics.DebuggerDisplay("Name = {Name} ")]
public partial class DataValue_CP : global::CP_Console.IDataValue
{
public int? lastUsedInterface ;

private global::CP_Console.IDataValue[] values;
public DataValue_CP(params global::CP_Console.IDataValue[] values){
this.values=values;
}
public int Count{
get{
return values.Length;
}
}
public global::CP_Console.IDataValue Get(int nr){
    return values[nr];
}




        public string Name { get
        {
        lastUsedInterface = null;
        foreach(var item in values){
        lastUsedInterface =(lastUsedInterface ??-1)+1;
        if(item == null)continue;
        try{
        return item.Name;
        }
        catch(Exception ){
        //try with the next one
        }
        }
        throw new System.Collections.Generic.KeyNotFoundException();
        }
        set
        {
        foreach(var item in values){
        if(item == null)continue;
        try{
        item.Name = value;
        }
        catch(Exception ){
        //try with the next one
        }
        }
        }

        } 
    
            public virtual  async  System.Threading.Tasks.Task<string> KeyFromValue(string key, bool defaultValue) {
                lastUsedInterface =null;
                foreach(var item in values){
                    lastUsedInterface =(lastUsedInterface ??-1)+1;
                    if(item == null)continue;
                    try{
                        var data=   await  item.KeyFromValue(key, defaultValue) ;
                        return data;
                    }
                    catch(Exception ){
                        //try with the next one
                    }
                }
                throw new System.Collections.Generic.KeyNotFoundException();
            }
        
}

Code and pdf at

https://ignatandrei.github.io/RSCG_Examples/v2/docs/RSCG_CompositeProvider

A Programmer with Microsoft tools

Friday links 505

RSCG – EntityLengths.Generator

Friday links 504

What I have learned by building .NET Stars -part 5 – always available data for a display website

RSCG-Composite Provider – part 2 -execution

{ADCES] Discutii si Networking

RSCG-Composite Provider – part 1 -idea

API Outage solved with local data

How It Works:

Making It Even Easier: Roslyn Code Generator to the Rescue

Friday links 503

Global AI Bootcamp Bucarest

RSCG – RSCG_CompositeProvider

API Outage solved with local data

How It Works:

Making It Even Easier: Roslyn Code Generator to the Rescue

Andrei Ignat weekly software news(mostly .NET)