What do you mean by "kits"? Can you log an issue at dotnet/core and then we can redirect it to the best repo?

@richlander
I have a problem with the " projects" of my libraries. The dependencies between each other do not work and all the libraries from nuget. Cleaning the cache does not help.

I'm trying to avoid each issue being super long here. Can you file this content in an issue?

You can use this handy feature.

Ok, sorry. Done #9183

@maartenba Quick tip: Use a news aggregator(such as Feedly, or any other rss reader) and add this feed to it: https://github.com/dotnet/core/discussions.atom

Getting notifications for announcements is great. However I also get notifications from all the comments (sorry everyone..). Until I can configure that I only want notifications for only announcements I'll have to unsubscribe to avoid all this spam.

Having to wait multiple months for this to be fixed isn't a great proposition. I also doubt this will be fixed because it requires changes to the way github handles notifications..

@sander1095 Subscribe to https://github.com/dotnet/core/discussions.atom in your RSS aggreator app/service

You can also subscribe to notifications at https://github.com/dotnet/announcements

@ErikEJ What if a normy like me doesn't and doesn't want to use an aggregator for one repo?

Hi @alexey-leonovich as of right now we don't have any announcements for a future version of Visual Studio so the current plan is yes it will be on VS 2022. Of course if there is any specific VS tooling that requires changes here in this plan we'll be sure to announce that, but none identified as of now.

This is important. I do not fancy having more than two versions of Visual Studio on my device.

right now we don't have any announcements for a future version of Visual Studio so the current plan is yes it will be on VS 2022

The .NET 6.0 story began same way for Visual Studio 2019 till April 2021 when Visual Studio 2022 was announced. Starting from May 2021 the following .NET 6.0 preview became exclusive for Visual Studio 2022. I hope this doesn't happen again for .NET 9.0.

In .NET 8, we expanded our investment beyond ML.NET

From the blog post yesterday. If you've got feature requests or questions, please log them at: https://github.com/dotnet/machinelearning

For IoT, it depends on what you want. If you want better perf, then that's at dotnet/runtime. If you want better APIs, then that's likely dotnet/iot.

Have you see these device bindings? https://github.com/dotnet/iot/blob/main/src/devices/README.md

No, I have not. Now I am. Thanks for pointing me on my way

Not your fault. I've done a very poor job telling that story. Something to fix.

I agree.

dotnet/runtime#96419

PDB support does appear to be on the list for this feature. @buyaa-n is there timeline for PDB support?

@buyaa-n :)

@pvillads we plan to add PDB support in 9.0, probably within preview 5. Here is the API proposal with usage example, please let us know if the proposal covers your scenarios.

Got it. It looks fine to me, although I am not sure I understand the role of the metadatabuilder. Is this abstraction really needed? It does seem a little complex to me, like some abstractions that are far below the API you are defining are leaking.

e.g. mdRootBuilder.Sizes.RowCounts needed in the constructor for the PortablePdbBuilder

The new design that will be introduced in preview 3 allows user to set/use wide range of assembly file and header options mentioned in the issue dotnet/runtime#97015

The PDB design is based on this new design, it might look a bit complicated, but it provides more options. In the future we could add a PersistedAssemblyBuilder.Save(...) overload that saves assembly and PDB with the default options too.

What is that in reference to?

@eiriktsarpalis

SqlClient issues?
https://github.com/dotnet/SqlClient/issues

@EthicalBen have you tried SqlClient 5.2?

@JonDouglas The content on ChatGPT does not contain the latest updated information of .Net. The copilot may charge the developer.

@ali50m Can you give us some example prompts and what you're hoping they would reply with? This will help us tremendously understand how to best fine tune or provide search plugins appropriately.

@JonDouglas For example,

1. how to create int arrays?

var data = new[] { 1, 2, 3, 4 };

or after .net 8 with C#12 released

int[] data = [1, 2, 3, 4];

2. How to inject a keyed service to Microsoft IOC container?, the bot will guide you with the latest feature intruduced in .Net8. I tried this question with Github copilot or ChatGPT 3.5, but didn`t get the right answer from them. My guess is that they are not trained with the latest development materials.

It will be cool If there is a free AI bot which always comes with the latest .net knowledge.

Wonderful. It sounds like you're mostly interested in a search plugin such as if something is outside a model's knowledge, it does a search query, gets a list of results, grabs a few sources, fetches relevant snippets/etc, then integrates em to formulate the response.

Will talk to the team further about this and seeing how we might be able to bring it into Copilot experiences.

Otherwise the next best time for something to include .NET 8 information would be the next major retrained model drop. I think today most models use pre-april 2023 training data.

@JonDouglas At first glance, I didn't read much into the original question. However after some reflection, I'd like to take an opportunity to describe in more detail the problem with LLMs in general when it comes to coding with .NET (and probably any other language, though I'm not as versed in other programming languages).

In my experience, LLMs have a really hard time separating their knowledge into version based boundaries. What applies to .NET Framework doesn't necessarily apply to .NET Standard versus .NET Core. What worked in .NET 6.0 may no longer work in .NET 8.0. What works in .NET 8.0 probably won't work in .NET 5.0. And that's just talking about the general .NET SDK. If you start including external concerns like Entity Framework Core, or NuGet packages (even popular ones like MassTransit), the more version specific context the LLM needs, the higher the probability the code examples it will provide will fail.

As a specific example, in a prior project, being that I'm not well versed in Vue.js, I was part of a team that had the task to create a new Vue.js version 3.0 SPA. The rest of the company had only worked with Vue.js 2.0. There are very huge conceptual changes between version 2.0 and version 3.0. The internal mechanics have completely changed and the new version heavily relies on the Composition API whilst the prior version was geared towards the Options API.

As an attempt to speed up our development and facilitate learning an ecosystem that's not part of my base skills, I attempted to lean into ChatGPT to aid in this journey. However, even with current knowledge of Vue.js 3.0, it could not distinguish between version 2.0 and version 3.0 and would often produce code that was completely incompatible in both versions of the framework.

At the time, we also tried to use LLMs to solve complex implementation details with Entity Framework Core 7.0 or 8.0 and it would often confuse itself between Entity Framework and Entity Framework Core.

It sounds like you're mostly interested in a search plugin such as if something is outside a model's knowledge, it does a search query, gets a list of results, grabs a few sources, fetches relevant snippets/etc, then integrates em to formulate the response.

To be completely transparent, I do not use Bing as a search engine because it tries to do this all the time. It's a great model to use when you're trying to summarize news articles and such, but it's a horrible way to do coding LLMs. There is simply too much knowledge, context, and compute required for any LLMs to be able to process in the time a user expects a response. This approach simply doesn't work.

I wish I had the skills and time to work on my own LLM because this is how I wish it would work:

1. Trained on a specific version of C#, say version 10, using a complete reference such as O'Reilly's "C# 10.0 in a Nutshell".
2. Trained on all of the knowledge of the specific version of the related .NET SDK, in this example it would be version 6.0.
3. Trained on all of the knowledge of the most popular external concerns most commonly used up until the next version of .NET, thus in this case for example, all of the knowledge for Entity Framework 6.0, and other such NuGet packages.
4. Then sealed, training stopped, and released as an LLM for .NET 6.0.

I have no idea how LLMs are created, how they're trained, how they're built, or how they work. I'm just trying to illustrate the issues specific to our industry when it comes to code compatibility and versioning which, in my experience, LLMs seem to have a very difficult time with.

As it stands right now, I still use LLMs in my day to day, but for mundate repetitive tasks such as filling in unimportant XML docs for things like operators in an IEquatable class. I don't try to do anything significant with them as they simply don't hold up the good old approach of taking the time to read all of the documentation required to do what I need to do.

@JonDouglas I'd like to share this concrete example with you regarding AI's, and in this case, Copilot's inability to understand very specific limitations of context.

I am in Visual Studio 2022 using an individual paid subscription of Copilot with all of the plugins installed and activated. Thus, Copilot has full control and all of the contextual information it needs.

1. I create a new .NET 8.0 Web Application without Controllers, thus using Minimal APIs.
2. I ask Copilot to refactor the MapGet to use a static handler method. It understands and does so perfectly.
3. I ask Copilot to add a model that accepts a City as a string and at a DateTime as a DateTimeOffset as an input to the static method handler, bound using AsParameters. This time Copilot gets there 50% of the way. The model is created correctly, but it names the model AsParameters and doesn't add the attribute the route. No problem, a quick rename, add the parameter, and we're done.
4. And then, this is where it breaks down.

---- Start of my explanation of my 4th step ----

I am testing Copilot's ability to help me iterate complex model binding using Minimal APIs different binding methods as described here:
https://learn.microsoft.com/en-us/aspnet/core/fundamentals/minimal-apis/parameter-binding?view=aspnetcore-8.0#binding-precedence

However, Copilot cannot differentiate between what is compatible with Controllers versus what is compatible with Minimal APIs. In this case, the proper extension point for complex models is BindAsync as described here:
https://learn.microsoft.com/en-us/aspnet/core/fundamentals/minimal-apis/parameter-binding?view=aspnetcore-8.0#bindasync

But since Copilot does not distinguish this level of context, no matter how much I try, no matter which prompts I use, it simply does not understand the specificity of my request.

This is what it will usually generate, which is only compatible with Controllers and the analyzers will produce ASP0003 due to its imcompatibility with Minimal APIs:
https://learn.microsoft.com/en-us/aspnet/core/diagnostics/asp0003?view=aspnetcore-8.0

internal static class WeatherForecastHandler
{
    public static IEnumerable<WeatherForecast> GetWeatherForecast([AsParameters][ModelBinder(typeof(WeatherQueryModelBinder))] WeatherQuery query, HttpContext context)
    {
        {
            var summaries = new[]
            {
            "Freezing", "Bracing", "Chilly", "Cool", "Mild", "Warm", "Balmy", "Hot", "Sweltering", "Scorching"
        };

            var forecast = Enumerable.Range(1, 5).Select(index =>
                new WeatherForecast
                (
                    DateOnly.FromDateTime(DateTime.Now.AddDays(index)),
                    Random.Shared.Next(-20, 55),
                    summaries[Random.Shared.Next(summaries.Length)]
                ))
                .ToArray();

            return forecast;
        }
    }
    internal static class WeatherQueryModelBinder
    {
        public static async Task BindAsync(ModelBindingContext bindingContext)
        {
            var valueProviderResult = bindingContext.ValueProvider.GetValue(bindingContext.FieldName);
            if (valueProviderResult == ValueProviderResult.None)
            {
                return;
            }

            var value = valueProviderResult.FirstValue;
            if (string.IsNullOrEmpty(value))
            {
                return;
            }

            // Perform custom binding logic here
            // Example: Parse the value and create a WeatherQuery object
            var weatherQuery = new WeatherQuery
            {
                City = value // Set the City property based on the value
            };

            bindingContext.Result = ModelBindingResult.Success(weatherQuery);
            await Task.CompletedTask;
        }
    }

    internal record WeatherQuery
    {
        public string City { get; init; }
        public DateTimeOffset DateTime { get; init; }
    }
}

---- End of my explanation of my 4th step ----

I thought this was a useful example that helps better illustrate my previous comments. Thanks!

/cc @timheuer @mikadumont