DEV Community: Mark Pelf

GitHub Copilot Agent looks promising – Part3 (June 2025)

Mark Pelf — Thu, 12 Jun 2025 08:13:29 +0000

GitHub Copilot Agent, as of June 2025, looks much more capable than it did 2 months ago.

Abstract: After the appearance of the GitHub Copilot Agent, I decided to try it on my real-life ASP.NET8 project of 123.000 SLOC. I tried some limited-scope tasks, and the initial results are much better than my GitHub Copilot tests two months ago.

1 GitHub Copilot in VS2022

I am working on the development of .NET8/C#/ASP.NET8/EF8 application, which is now around 123.000 lines of code (SLOC), out of which 50.000 is EF-database-first model, in Visual Studio 2022.

I have a subscription to GitHub Copilot Pro + license. So far, that AI tool has been good for limited-scope tasks. I wanted to try the new GitHub Copilot Agent mode. Below are notes from my regular work.

Environment is:

Visual Studio 2022, 17.14.5
GitHub Copilot (GHC). License Copilot Pro+
Agent mode, GPT-4o, GPT-4.1, Claude 3.7 Sonnet

2 Anecdotal Experience with Real ASP.NET8 project

The task is described in “Part2” of this series. Here is just my further analysis.

3 Analysis – Impressions

3.1 Human reviewing GHC-generated code in the previous task (regarding Part2)

I was looking very carefully at the generated code. Here are my findings.

First, it is clean of syntax errors (C#) or similar nonsense, like extra brackets, which was a big problem 3 months ago.
Not a single time I saw “hallucinated C# class property or member” that I saw 3 months ago in quantity that made generated code unusable because of re-work needed to fix all that garbage. This time is much, much smarter, I would say not a single level of quality up, but several levels of quality up. I do not know how, but that was a big problem, and it looked like GHC was trying to “guess out” properties names, instead of looking into the EF model. This time, it looked into other files of code of the project (no other way to find the right property names) and did the comparison/match. 3 months ago, I was thinking that LLMs are unusable for coding because of the hallucination problem, but they solved that. Even the fact that my DB table names are partly English, partly German, was not a problem; it figured that Contract==Vertrag, Account==Konto, etc. It is not that simple for a machine; English and German names are mixed in DB table names, C# class names, method parameters, etc.
I told it to copy ALL COMMENTS, but it didn’t. It copied most of it. I am human and I need those comments, because 3 months later, when I look into the code, I do not remember proper API usage, so I leave comments on why and how it was invoked. I reviewed the code and copied the comments I like myself. It is not a big problem, but I noticed, GHC does not follow the given instructions strictly, it is “like a human coworker”, it does most of it, but changes a bit to its liking.
Because the task was to make new code based on the original template, it looks simple. But it is not for the machine. So, GHC changes are right, it looks like it was able to “understand” the code and figure out where it needs to change the template, and where it doesn't. That is not simple at all, but it figured it right. There are many technologies involved, MVC Razor/HTML,CSS/JS/jQuery/Databable.net in 370 lines of code (.cshtml), and to figure out which string belongs to which library is no easy task for a machine. Simply, as far as I can see, GHC figured it all out and got it right.
I didn’t ask for it, but during copying from the original template, it removed some dead JS code. I probably copied some JS functions, but later I did not need them, so they stayed there. OK, the new file is faster because it will need to load 15 lines of JS code less in the browser, but that is not the point. The point is, GHC “knows what is doing”, and that is sometimes what you want from a coworker, not just to do the task, but to fix little things-problems it notices during work, without explicit request for that.
There is one subtle thing I am doing in my ASP.NET8 View-Component and GHC didn’t get it at first, and I needed to ask for several commands to finally do it, but once it figured it out, it figured it out better than I expected. So, in a view file (.cshtml) I am using a boolean flag ((Model?.IsSelectable), to make from one component actually 2 components, one editable and one read-only. Based on that flag, I show or hide some HTML/Datatables.net elements in .cshtml file. It is kind of tricky, because you have a mixture of MVC Razor/HTML/ CSS/JS/ jQuery/Databable.net languages. It looks like GHC didn’t get it in the first iteration/command. Then in the second, it copied HTML that is generated only in the default case Model?.IsSelectable==false. In the third iteration/command, I told it to include that flag, and it did with all the proper syntax. I still didn’t run it, but by reviewing the file visually, it looks like all the HTML/JS syntax is OK. But it did even more. I am using a boolean flag ((Model?.IsSelectable) in the original template just to show/hide visual HTML elements, and load ALL the JS code anyway. What GHC thing did is, it got the idea, why load all the JS code, when you do not need the “selectable part of JS code” if the component is read-only. And based on its own initiative, it implemented the same Boolean flag to include/exclude parts of JS code. Yes, I agree, that is an improvement, not big since that is maybe 100 lines of JS, but I did not care about that because I was just happy to get the component working. I do not know how GHC works from inside, but from my point of view, it appears that GHC “understands” that the .cshtml view file is about to be loaded into a browser, and for performance reasons, optimizations are possible. And on its own initiative, implemented optimization, and as far as I can see, looks like it all syntax and functionality is fine. It is a small performance improvement ( 100 lines of JS), but the big thing is “GHC looks like it knows what it is doing”.

4 Conclusion

Again, this was a small task, and this was still a task carefully chosen for GHC, in the sense that it is template-based and component-separated from the main code. It only needed to clone the code and adapt it from the Account entity to the Contract entity. But before, GHC would fail even in such “Gen-AI favorable scenarios”.

But, compared to several months ago, this “GitHub Copilot Agent” looks much, much smarter. It actually feels (on this smaller task, based on produced results) a bit like human coworker, does not figure it right away, so you need to explain details more, it does quality job, but it does not do exactly what you asked and does some things his own way, and sometimes is more clever that you think it will be.

Based on modifications GHC made to the code of my original template C#/cshtml 4 files, I was able to follow “how GHC is thinking”, and it does think like a good programmer.

To be continued…

GitHub Copilot Agent looks promising – Part2 (June 2025)

Mark Pelf — Thu, 12 Jun 2025 08:10:55 +0000

GitHub Copilot Agent, as of June 2025, looks much more capable than it did 2 months ago.

1 GitHub Copilot in VS2022

I am working on the development of .NET8/C#/ASP.NET8/EF8 application, which is now around 123.000 lines of code (SLOC), out of which 50.000 is EF-database-first model, in Visual Studio 2022.

2 Anecdotal Experience with Real ASP.NET8 project

Environment is:

Visual Studio 2022, 17.14.4
GitHub Copilot (GHC). License Copilot Pro+
Agent mode, GPT-4o, GPT-4.1, Claude 3.7 Sonnet

The task is:

The task is to create a similar View-Component based existing.
Context is WebApp (.dll) in this moment is ~66.000 SLOC , different technologies, C#, JavaScript, jQuery, Bootstrap, HTML, CSS, ASP.NET8, MVC, Razor.
The task to GHC is to create new View-Component based on the existing template. It is 4 files in different technologies. Still, it is pattern-based, practically just Contract and Account need to be switched. It is a component, so it is independent from the main app code, and it limited scope.
Component uses AJAX, so the Controller method for the component needs to be created too

2.1 Create a new AJAX method in ASP.NET MVC controller based on the existing

That is 80 lines of C# code method, just is referencing DataAccessLayer dll TBServerUI.Data. It is pattern-based; it should be no problem.

2.1.1 GHC (GPT-4o)

(Run1-GHC (GPT-4o) ) My request COMMAND to GHC (GPT-4o) was :
- Based on method AccountsListForContractDT_AJAX in file #AccountsController.cs, create a similar method where Contract and Account roles are switched, called ContractsListForAccountDT_AJAX . Context is TBServerUI.WebApp project. In implementation, you will need to use Contracts_ContractsForAccountListDT from TBServerUI.Data project.
It worked a 3 minutes, it added a method, it tried to build, it built. I looked into it. IT IS GOOD. It was pattern-based, but it did exactly what I would do manually. Just put it in AccountController, I want it in ContractController.
So, I asked to move that method to the other controller class, and it did. It was built again to verify that it all builds.
It looks GHC has some problems if VS2022 project/solution is not opened in the proper folder/view/tab. It couldn’t find the C# file. So I helped it a bit, by observing GHC-Chat-Window, which is practically a Log of what is doing, and when it was not able to find some file, I navigated VS2022 to that file/class. Then it was unstuck and continued to work.
I AM IMPRESSED. IT DOES FEEL AS IF YOU HAVE A COMPETENT COOWORKER THAT GETS INSTRUCTIONS FROM YOU AND YOU CAN DELEGATE WORK TO HIM/HER.
And commands/instructions I gave to GHC are quite normal, as I would give to some coworker, not too much of “prompt engineering pseudo science tricks” were needed. Quite a natural language. OK, I admit, I was skeptical in the past, but this looks like real AI.
The fact that GHC automates VS2022 has a big psychological effect… really looks like someone else has overtaken control of your dev tools.
I am using Git, and that is my line of defense; there, I observe every change made to project files and review each one before accepting it. I kind of do not trust AI messing with my project, without me having firm control of every line that is about to be changed.
I do read AI-generated code, but in the past, it happened that I overlooked some small change AI added, and that created problems later. What happened before, AI-generated code in case of method failure returned an empty object from the default constructor, and I usually return null in case of failure, so it messed with logic in upper invoking methods. I just didn’t see such a small deviation in code created by AI. That is why I say, be careful, AI follows some textbox conventions (from who knows which author), not your project conventions.
In this case, I read 80 lines of code, and it looks fine, but I am not a compiler, just a human, maybe some small error is somewhere.

2.2 Create a new ASP.NET View-Component based on template (4 files)

This is a bit more tricky task. It is still template-based, but involves 4 files and several different technologies.
Still, the component is a limited-scope task.
On the other hand, many ASP.NET developers do not know or use View Components.

2.2.1 GHC (GPT-4o)

(Run2-GHC (GPT-4o) ) My request COMMAND to GHC (GPT-4o) was :
- Based on View-Component AccountsForContractSelectableViewComponent in file #AccountsForContractSelectableViewComponent.cs, create a similar View-Component where Contract and Account roles are switched, called ContractsForAccountSelectableViewComponent. Context is TBServerUI.WebApp project. AccountsForContractSelectableViewComponent consists of several files: 1) AccountsForContractSelectableViewComponent.cs; 2) AccountsForContractSelectableViewComponent_Model.cs; 3) AccountsForContractSelectableViewComponent_ViewModel.cs; 4) AccountsForContractSelectable_Default.cshtml. You will need to refer to AJAX method ContractsListForAccountDT_AJAX in generated ContractsForAccountSelectable_Default.cshtml.
It worked for only a few minutes, and it built that work, but it was not good. It created classes for the first 3 files and embedded them into existing files. Maybe I should have told it to create new files? It didn’t create Razor view .cshtml, which is quite complicated, 477 lines of code, most JavaScript. Let’s see if we can make it do it.

(Run3-GHC (GPT-4o) ) My request COMMAND to GHC (GPT-4o) was :
- Move classes ContractsForAccountSelectableViewComponent_Model, ContractsForAccountSelectableViewComponent_ViewModel, ContractsForAccountSelectableViewComponent into their own files. File locations are same as model files on which they were generated.
It did it right, and now it looks better. Maybe complex tasks need to be broken into subtasks.
I created manually view file ContractsForAccountSelectable_Default.cshtml, because it looks like that is confusing GHC.
This Razor view with a lot of JavaScript, so let’s see how it goes
(Run4-GHC (GPT-4o) ) My request COMMAND to GHC (GPT-4o) was (***) :
- Based on Razor view file AccountsForContractSelectable_Default.cshtml create file ContractsForAccountSelectable_Default.cshtml as a view for component ContractsForAccountSelectableViewComponent, where Contract and Account roles are switched. In file ContractsForAccountSelectable_Default.cshtml create Datatable columns same as in ContractsList.cshtml. You will need to reference AJAX call to ContractsListForAccountDT_AJAX in controller Contracts.
It failed. Some errors. I will try again
(Run5-GHC (GPT-4o) ) My request COMMAND to GHC (GPT-4o) was ()
This time it produced buildable code. Let’s check.
It was not good at all. It used wrong model class, and created some mess with JavaScript
(Run6-GHC (GPT-4o) ) My request COMMAND to GHC (GPT-4o) was ()
- Replace all JavaScript section in ContractsForAccountSelectable_Default.cshtml with JavaScript from AccountsForContractSelectable_Default.cshtml, and just adopt it to use Contracts_ContractsListDT_Json object
Result was buildable, but JavaScript is not good. It shorten it a lot.
(Run7-GHC (GPT-4o) ) My request COMMAND to GHC (GPT-4o) was (***)
- Replace all JavaScript section in ContractsForAccountSelectable_Default.cshtml with JavaScript from AccountsForContractSelectable_Default.cshtml, and just adopt it to use Contracts_ContractsListDT_Json object. Copy also all comments in code from AccountsForContractSelectable_Default.cshtml, just adopt it to new file. Copy also sections that are triggered with Model?.IsSelectable flag when possible.
I have read the result, which is maybe 330 lines of JavaScript that invoke some libraries. I found a small mistake, not syntax, but it didn’t pass some parameter. VS2022 can not test syntax on JavaScript embedded in Razor, but I followed it manually, and it looks solid. Only running in the browser will show any errors. But it followed a pattern, improvised some things, ok- good improvisations. Made a usable base for me to modify manually. It didn’t follow my pattern for brackets; it followed textbook rules, but OK. In one place, it looks like it searched the code for the proper icon method and found the right one. It even added some smarts too, based on some flag, including/excluding some JS code. I didn’t care if a “dead code” JS method is there. It even cleaned some “dead code” methods that I initially added to the original file but later abandoned. I can actually understand what GHC wanted to do and why. It got right, which are primary keys in Accounts/Contract, and which need to be passed to other methods after selection. That is quite clever.

So, it had a problem with that Razor MVC file with a lot of JavaScript, and needed help with it. It made 3 easy files right away, and it needed help with the 4^th one.
Very important: I did not notice garbage code in JavaScript or an obvious mess, as I saw 2 months ago.
Component needs to be tested, of course, but it looks like I got a solid codebase, with just a few modifications (~6 lines) to the generated code. And 7 prompt commands altogether.

3 Conclusion

This was still a task carefully chosen for GHC, in the sense that it is template-based and component-separated from the main code. It only needed to clone the code and adapt it from the Account entity to the Contract entity. But before, GHC would fail even in such “Gen-AI favorable scenarios”. So, the above shows 7 prompts that created ~500 lines of code, with small interventions from a human programmer ~6 lines of code, and some empty file creation. And commands are in practically natural language, no “pseudo-science” prompt engineering needed, I spontaneously stopped using # for marking file names, and it all worked.

I have always stated that prompt engineering is “a defeat for AI” and with the advancement of AI, it will become obsolete as natural language communication will prevail.

Impression*: This version of GitHub Copilot (GHC) Agent is much, much stronger than GHC I saw a few months ago. There is no mess in the code I saw 2 months ago. I did not see a single hallucinated method or property, and the code is buildable, meaning syntax is proper.* The automation of Visual Studio 2022 (remote control by GHC) has a kind of psychological effect; you feel like someone else is present and has taken over the control of your tools. VS2022 is alive without me doing anything. It actually builds and repeats builds after errors.

It does not feel like “pair programming” or “peer programming” as in marketing stories. GHC is quite passive, so it feels like an “intelligent code generator”. But it does look effort-efficient. In the above work, I made altogether 7 commands to GHC, and got some 500 lines of usable code. But you still need a human proficient programmer to filter out bad attempts and tweak code in a couple of places.

GitHub Copilot Agent looks promising – Part1 (June 2025)

Mark Pelf — Thu, 12 Jun 2025 08:09:16 +0000

GitHub Copilot Agent, as of June 2025, looks much more capable than it did 2 months ago.

1 GitHub Copilot in VS2022

I am working on the development of .NET8/C#/ASP.NET8/EF8 application, which is now around 123.000 lines of code (SLOC), out of which 50.000 is EF-database-first model, in Visual Studio 2022.

2 Anecdotal Experience with Real ASP.NET8 project

All below was done with:

Visual Studio 2022, 17.14.4
GitHub Copilot (GHC). License Copilot Pro+
Agent mode, GPT-4o, GPT-4.1, Claude 3.7 Sonnet

2.1 Code review of Data-Access-Layer dll

Context is DAL layer (.dll) in this moment is ~62.000 SLOC C# (and it will grow), and out of that 50.000 is EF model (EF-database-first).
That is a kind of limited scope task, clear C# code, .NET8
Wanted to do a code review and see what this AI thing will do
(Run1-GHC (GPT-4o) ) My request COMMAND to GHC (GPT-4o) was (*)
- I want you to do a Code Review of the project TBServerUI.Data.csproj. Identify possible software defects, and places for possible improvement of code.
Response was quick, and it said it “read 786 files” of the project. That sounds like a good start.
Replay was quite shallow. I kind of expected it would understand a bit what that .dll is doing, but it was giving me suggestions like “avoid magic number/strings” in code and “refactor method because it has too many parameters”. I do things like “shorten string to max 30 characters” before I put it in the database, and number 30 is ok there, it would just obfuscate code if I were to define const THIRTY=30 or similar garbage. I do not need that, problems I have are like 1000 times more complex, and AI gives worthless suggestions.
My expectations were higher. No human can keep and memory 786 files, so my hope was that the AI machine would load it all and figure out some smarter advice, that I can not see because there are so many files. I actually know places where I made “dirty code” to make things work and left it there, to refine it later. That GHC thing didn’t see that.
(Run2-GHC (GPT-4o) ) I run several times same command () to GHC (GPT-4o), to give it a chance to improve on response. Funny thing, I told it to do the same all over again (same command), but it did NOT read again all 786 classes, just 2 of them. I saw that before, that GHC thing is not following even full sentence instructions, it does what it wants to do.
(Run3-GHC (GPT-4o) ) I needed to close all open files in the editor to make it re-read all 786 files. Why do I need to do that? I was giving explicit full sentence commands () to review the whole project?
Again, a pretty formal response, several pages of text, but no real substance.
(Run4-GHC (GPT-4.1)) I tried same command () to GHC (GPT-4.1).
Answer is similar, formal, with suggestions if I want “deeper review, I must ask for it specifically for a certain class/file”. There are many files; why do I need to ask file by file?
(Run5-GHC (Claude 3.7 Sonnet)) I tried the same command () to GHC (Claude 3.7 Sonnet).
This time, it was quite slow in response. It said it read 786 files. Does slow mean it is doing something? I got a response finally.
The first thing is a funny one. AI thing was reading MY OWN COMMENTS IN CODE, not the code itself, and was telling me I sound “insecure” in my comments. I do not need an opinion on my comments, I need an opinion on my code. Based on my comments, it gives an evaluation of my code. If I have put a comment like “this is a great method,” would it think it is great? So, the quote of GHC is here: “The comment 'hope this is enough to prevent SQL injection' indicates uncertainty about the security measures. This should be thoroughly tested and validated.” If my company sees that, they will need to hire a Junior guy, they are ALWAYS SURE they covered all the possibilities, no matter what code they write. Funny, GHC is giving a psychological profile of developers instead of looking into real code to see if it works.
It picked on some interfaces in libraries that are marked as “obsolete”, and I use them deliberately because the Project Owner wants me to keep them all on.NET8, and I would need to upgrade the project to .NET9 to use the latest interfaces. GHC is quite shallow here, such comments would mislead someone into the project that can not be compiled.
OK, it found some properties that it sees as mutable, I do only reads from them, but yes, they are not marked as read-only, so in multithreading, there could be problems… I didn’t see that before…
Some other minor comments… nothing I find useful… refactor this or that, split interface into several smaller interfaces, all cosmetic code changes.
Ok. Enough of code review for now.

2.2 Create a new method based on the existing

The task is to create a similar method based on a 200-line C# template method
The task to GHC was to create a DB access method based on a similar one, just to reverse Contract-Account roles. The original method is ~200 lines of C# code, but it uses EF-Core, LINQ, and some Data library classes and references some DTO classes. Still, it is quite easy, I would need 15 min, but I understand the DAL layer in this moment is ~62.000 SLOC (and it will grow), and out of that 50.000 is EF model (EF-database-first).

2.2.1 GHC (GPT-4o)

(Run1-GHC (GPT-4o) ) My request COMMAND to GHC (GPT-4o) was (**):
- Based on method Accounts_AccountsForContractListDT in file #DbWork.Contracts.cs, create a similar method where Contract and Account roles are switched, called Contracts_ContractsForAccountListDT. Context is TBServerUI.Data project.
So, it was running for like full 4 minutes doing something, automated VS2022, source code window opened, it was entering text, then tried a build, and the report shows no errors in the second build. Looked impressive, that automation of VS2022 made me first time feel there is somebody else present. Let us see what it made.
It created a method. Added to proper file (not the same file where original Accounts_AccountsForContractListDT (DbWork.Accounts.cs) method is, but to DbWork.Contracts.cs.
I was looking into the generated method content. It looks pretty good. The truth is I am doing a lot of work with the proper naming of all the classes in the project, so it could find the DTO just by naming conventions. But still, it found the right DTO classes. I am not a machine/compiler, but the method looks good to me. I can not really see all the details, if they are completely right.
One of the problems I noticed before with Gen-AI is that they produce a lot of text, and it is quite difficult and time-consuming to review it properly. It happened in the past, I was accepting Gen-AI code, but there was a small bug hidden that I did not notice.
So, key LINQ/EF queries looked fine. It even figured German names from the database, it is KONTO, VERTRAG table, not ACCOUNTS, CONTRACTS. And primary keys are KONTO_NR, VERTRAG_NR, etc. It figured it, and it looks like it is doing the right filtering.
It added some processing to the result that is specific for Contracts, and is not symmetric to the Accounts method I instructed it. It looks like it is quite clever, it looks like it found it somewhere in the project source code and inserted it here. Yes, the guess is right, it should be there. That is my code that is copied here, just even I can not fully review (do not remember) if all details are fine. This AI thing, of course, does not know what “Ebics Users” is, but it just saw the property “numberEbicsUsers” and it hacked it, found somewhere in the project method that calculates that property and assigned it. And the guess was good.
There is one Boolean flag that stayed unused, but that is a minor thing compared to all the other. I will set that flag.
So, looks like a good job. It compiles. No hallucinated properties/methods this time. Much better than what I have seen before for GHC.
Let’s see what other LLMs will do.

2.2.2 GHC (GPT-4.1)

(Run2-GHC (GPT-4.1) ) My request COMMAND to GHC (GPT-4.1) was (**) again.
It started to work on something. Then, in the chat window, it was loading like 6 files from the project. Then it said it is going to load 786 files of the project. Then it breaks, with an error in VS2022:
- {"error":{"message":"prompt token count of 64602 exceeds the limit of 64000","code":"model_max_prompt_tokens_exceeded"}}
It failed. Some GHC error. Let’s restart VS2022 and try all again.
(Run3-GHC (GPT-4.1) ) My request COMMAND to GHC (GPT-4.1) was (**) again.
It was running for a while. From the Chat dialog ( which actually serves as a Log window) it can be seen that it loaded a limited number of files. It was stuck, it couldn’t find/load some model C# file. It tried several times and failed. Then I manually navigated (actually, I was just checking if the file was there) and it continued.
Then it proposed a plan of changes and stopped. I was looking, but nothing was generated. So I just typed: “continue with your plan,” and it continued and did it. And it created code, and built it, and the build was successful.
I looked into the solution, and it looked the same as above by GPT-4o. At least the key parts that I checked are the same. All comments from above apply here too.

2.2.3 GHC (Claude 3.7 Sonnet)

(Run4-GHC (Claude 3.7 Sonnet) ) My request COMMAND to GHC (Claude 3.7 Sonnet) was (**) again.
Execution failed after 5 minutes with message:
- {"error":{"message":"prompt token count of 95998 exceeds the limit of 90000","code":"model_max_prompt_tokens_exceeded"}}
It failed. Let’s restart VS2022 and try all again.
(Run5-GHC (Claude 3.7 Sonnet) ) My request COMMAND to GHC (Claude 3.7 Sonnet) was (**) again.
Execution failed after 5 minutes. The error was different:
- [Conversations Information] [CopilotClient] Copilot Internal User response: Conversations.Abstractions.Auth.CopilotUserData; [Conversations Information] [CopilotModels] Environment variable COPILOT_USE_DEFAULTPROXY found: False; [Conversations Information] Copilot auth status: OK. Copilot badge status: Active
I checked. My internet connection looked fine. On this machine I have 190Mbps/19Mbps.
Let’s restart VS2022 and try all again.
(Run6-GHC (Claude 3.7 Sonnet) ) My request COMMAND to GHC (Claude 3.7 Sonnet) was (**) again.
Execution failed after 10 minutes. Error was:
- [PersistedCopilotSessionRepository Error] Error saving updated session: MessagePack.MessagePackSerializationException: Failed to serialize Microsoft.VisualStudio.Copilot.CopilotInteraction value; [Conversations Information] [CopilotClient] Copilot Internal User response: Conversations.Abstractions.Auth.CopilotUserData; [Conversations Information] [CopilotModels] Environment variable COPILOT_USE_DEFAULTPROXY found: False; [Conversations Information] Copilot auth status: OK. Copilot badge status: Active

3 Conclusion

These are, of course, limited tests involving the generation of a single method based on a clear pattern. However, even with such straightforward tasks, GHC previously either failed entirely or produced code that required substantial manual correction.

So far, the improvements are dramatic compared to two months ago. Back then, the code generated by GHC often wouldn’t compile right away and suffered from odd syntax issues, like misplaced or mismatched brackets around code blocks. Even worse, it frequently included hallucinated method or property names that didn’t exist in the project. It did not look like a meaningful work process.

Now, the generated code has correct syntax, compiles right away, and the referred properties/methods do exist. This time, it actually starts to look like a proper work process. GHC Agent automates VS2022, so on a psychological level, it actually looks like someone else has overtaken control of your dev tools.

I'll keep testing it/working with more complex scenarios, but the GitHub Copilot Agent mode already feels like a significant step forward in quality.

Reusing Spare HDDs and SSDs with USB Disk Enclosures

Mark Pelf — Tue, 22 Apr 2025 15:45:38 +0000

This article demonstrates how to give old, unused hard drives and solid-state drives new life by using USB external enclosures.

Abstract: We show how spare HDDs and SSDs from old laptops or upgrades can be reused as external storage through affordable USB enclosures.

1 Repurposing Spare HDDs and SSDs

After upgrading several laptops, I was left with a handful of spare HDDs and SSDs. Rather than letting them sit idle, I decided to repurpose them as external storage devices using USB enclosures.

1.1 Magnetic Media Degradation Over Time

It’s well known that all magnetic media—including tapes, HDDs, and SSDs—deteriorate over time. While this process can take years or even decades, SSDs are particularly vulnerable: if left unpowered, some can begin to lose data within just six months ([1]). This makes traditional HDDs a more reliable option for long-term storage, especially for important files like family photos.

1.2 Affordable USB Enclosures

I discovered very affordable disk enclosures on Temu.com and purchased several to use with my spare drives. The following sections detail the setup and performance of these drives in their new roles.

2 Disk 1: Old laptop 512GB HDD

Here are specifications of this upgrade:

Old laptop 512GB HDD
Enclosure: USB C, 3.1 Gen2
Brand: Temu.com, 6 Euros

Pictures below describe the upgrade and speed test.

3 Disk 2: Old laptop 2TB HDD

Here are specifications of this upgrade:

Old laptop 2TB HDD
Enclosure: USB C, 3.1 Gen2
Brand: Temu.com, 4 Euros

Pictures below describe the upgrade and speed test.

4 Disk 3: Old laptop 512GB SSD

Here are specifications of this upgrade:

Old laptop 512GB SSD (leftover after upgrade of laptop SSD to bigger one)
Enclosure: USB C, 3.2
Brand: Temu.com, 10 Euros

Pictures below describe the upgrade and speed test.

5 Speed comparison with Commercial External USB SSD

For speed comparison, here is commercial product Samsung PSSD T9 2TB, USB C 3.2 Gen 2x2.

6 Conclusion

The USB enclosures tested offer an inexpensive and practical way to reuse old HDDs and SSDs. They are especially useful for archiving valuable data such as family photos, where long-term reliability is important.

7 References

[1] Unpowered SSD endurance investigation finds severe data loss and performance issues

https://www.tomshardware.com/pc-components/storage/unpowered-ssd-endurance-investigation-finds-severe-data-loss-and-performance-issues-reminds-us-of-the-importance-of-refreshing-backups

GitHub Copilot (Gen-AI) is Helpful, But Not Great (March 2025)

Mark Pelf — Sat, 05 Apr 2025 10:53:12 +0000

Impressions from Using GitHub Copilot Pro in Professional ASP.NET 8 / C# Development.

Abstract: Here are my thoughts after using GitHub Copilot Pro in real-world ASP.NET 8 development over the past three months. Since technology evolves rapidly, it's worth noting that these impressions are based on my experience as of March 2025..

1 Free trial prompted me to subscribe to GitHub Copilot Pro

I have read about AI code generators and watched some demo videos in the past, but I was not convinced that they are really production-ready.

Without a reason, 3 months ago, due to a GitHub Copilot Free account being automatically activated in my Visual Studio 2022 in my ASP.NET8 project, so-called “ghost text” code suggestions started to appear. I was shocked, at moments it was a brilliant prediction of what I was about to write/code.

For those that are unfamiliar, “ghost text” is GitHub Copilot (GHC) suggestions presented to the user in grayed semi-transparent text that appears without reason as a prediction by AI of what the user is to do next. If a user likes the suggested code, just confirms it, or ignores it and does his/her work.

In a few days, I decided to subscribe to the full GitHub Copilot PRO subscription to check out that tool.

2 Preparing for GitHub Copilot - AI usage

2.1 Training

I always take tools seriously, so I read manuals in advance, to be able to use tools to their full potential and be aware of limitations.

I have listened for about 10 hours of videos on GitHub Copilot, topics like “prompt engineering”, “what is context”, etc. I made my own “cheat sheet” of prompt commands and shortcut keys. After 10 hours of training, I was ready to try it in my real-life professional coding in ASP.NET 8/C#/Bootstrap/EF8/JS environment.

2.2 Prompt Engineering in general

In my opinion, “Prompt Engineering” is a defeat for AI. One of the first definitions I heard of AI systems 20 years ago was that AI would be achieved when we would be able to talk to computer systems in natural language.

Now they tell you that GHC is an AI system, but you can not really talk to it in “natural language”; you need to use “prompt engineering”, which is really a sublanguage of natural language, and use symbols like /, #, and @. That looks to me like some mixture of natural language and programming language. They want to sell you their AI systems they have NOW, and 5 years from now, they will probably be telling you “now we have REAL AI, no prompt engineering needed anymore”.

So, the expression “prompt engineering” is coming from the period when the only way of interacting with an AI system was via a command prompt. Then, some “art” or “science” ( I would call it “pseudo-science”) in creating commands would help you make those AI systems work better. I have read several such articles, which are all “common sense”, but since the target AI system is always a “black box”, there are no real metrics to show if one author's recommendations are better than another person's list of rules. Also, systems evolved and changed over time, so strictly speaking, those authors would need to test their recommendations against the new generation of systems again. Typically, they do not do that, but offer “common sense” rationale which is based on the perception of AI as another human intellect. And what is “common sense” for humans might not be the same for AI systems. So, I am a bit skeptical and do not fully believe all the recommendations regarding “prompt engineering” that are out there because there are no real metrics and tests against different generations of AI systems. They offer just “common sense” and anecdotal proof from a few command executions.

2.3. Prompt Engineering in GitHub Copilot

So, when talking about “prompt engineering” in the context of GitHub Copilot (GHC) system, that includes not only the command line interface, but also some interaction via the Visual Studio GUI. That is basically “the user interface of GitHub Copilot”.

If one plans to use GitHub Copilot efficiently, they need to get familiar with GitHub Copilot UI. So, I did, learned all the commands like /fix, /optimize, #file1.cs, Alt+/ (invoke GitHub Copilot) etc.

2.4 Universe of the conversation

When I was studying philosophy in high school many years ago, I was taught about the concept of the “Universe of the conversation”. In every conversation, it is implied, and topics in conversation typically refer current “Universe of the conversation”. It helps people understand what is being talked about, as certain topics and terms are assumed or taken for granted within that framework. That is a philosophy concept, defined many centuries ago, describing communication between humans. And its definition will not change as long as there are humans on Earth.

2.5 What is “context” in the AI world

Tech companies doing AI invented the term “context,” which has a similar meaning to above mentioned philosophy term. I would like to keep terms separate, because Tech companies like to force their definitions of what the world should look like, in an effort to sell their products and shares. Also, there will probably be a definition of AI-Context-2025 and a new definition of AI-Context-2026, and so on, as technology develops.

The way I see it, the philosophy term “Universe of the conversation” will stay the same because it describes communication between humans. “Context”, on the other hand, describes communication between humans and AI-systems, and its definition will change with different technology generations of AI-systems.

So, the current context definition as of March 2025 (you can call it AI-Context-2025 ) would be: additional information the user needs to supply to the AI system for it to understand what it is required to do.

2.6 What is “context” in the GitHub Copilot

In training videos for GitHub Copilot, there has been a lot of emphasis on providing the proper “context” for your requests. To me, it looks like they ask for explicitly enumerating the files that contain relevant code. I would assume that “implied context” would be your Visual Studio project/solution, but it is not, in this moment of time, at least.

Actually, there is a little GUI check-box in GitHub Copilot VS2022 you click to confirm that you want the current open document to be included in the “context” of your every request. (by the way, they call it “prompt engineering” and you are clicking GUI check boxes… maybe “GUI engineering” would be a better name 😉 ). You are also asked to enumerate relevant files by using the # prefix, like #file1.cs.

So, if you want to use GitHub Copilot efficiently, there is a certain procedure on how to use it and a recommended command prompt/GUI interface for it. So, be it. I have learned/read all the instructions, and wanted to see the AI thing generate nice code for my VS2022 project.

The way I get it, they want you to be very specific in your request and enumerate all the relevant files with code. I see it as similar to giving instructions to another programmer, with certain specificity. It is not difficult, compared to the numerous programming languages developers learn.

3 Impressions after 1st week

GHC is just a code-assistant tool. It is not that “intelligent,” and “smart”, but it is good with repetitive tasks and can save some time typing. It is good for re-applying a pattern you have in code again and again, but it was very, very stupid in creating an original solution.

It is a waste of time to “chat to it”, faster is to go to Google and read for yourself to solve some original problem.

But once I create a nice pattern to solve something, it can save some typing, because it learns that pattern and reapplies it again automatically.

It also tends to generate a lot of “trash code,” so a human must filter what is generated, but it is not difficult to use the “delete” button, and keep just “good snippets”.

Let’s say, based on what I have seen so far, I expect it can save me 5% of the time in typing.

4 Impressions after 1.5 months

GitHub-Copilot (Gen-AI) is helpful, but not great. It is useful sometimes, but only for local scope problems, cannot see the bigger picture.

Sometimes it is brilliant, but sometimes it makes too many mistakes, and when asked, gives answers in several pages of text, wasting your time, especially because the verbose answers it gives are often off-topic.

In serious problems is useless; better to read a StackOverflow article by myself and figure it out. But sometimes, it excels and generates pretty good code for repetitive tasks.

My “personal feeling” is “it does not know it well”, it is “trying to guess it out”, and since it is a machine with huge memory of millions of lines of code memorized, guesses are sometimes brilliant, sometimes off-topic.

5 Impressions after 3 months

GitHub Copilot (GHC) is a Gen-AI tool that is quite useful in tasks of limited scope.

GHC is sometimes brilliant. So, yes, sometimes GHC is brilliant in predicting what you are about to code, and prompts you with “ghost text” that you just need to accept into your code.
GHC learns fast. GHC very fast learns your style of programming (how I handle and log exceptions) better than any coworker around, and follows your style in offering you predicted “ghost text” code. I like that so much, every person around tends to have his/her own style in making logs, etc.
GHC dangerously adds its own style. GHC is dangerous because it thinks it is smarter than you and will change a bit things its own way, without you noticing it. In database retrieval, in case of an exception, I was returning null. GHC prompted me with “ghost text” during coding to finish my method, and I just had a short look and accepted it. It created a bug; instead of null during an exception, it was returning an empty object, and my code elsewhere was breaking. Moral is: read carefully the code suggestions that it is offering to you before accepting them.
GHC can “generate code” but does not “write code”. Hard to explain, but simply, GHC does not understand C# syntax well. It creates brilliant snippets of C#, but with small syntax errors. You need to do a separate syntax check on the code you get from GHC. That is definitely not what we are accustomed to getting from machine/automated code assistants.
GHC does not understand C# syntax well. First of all, it fails on nullability like string vs string? type. You need to check it with the compiler and polish it by yourself. Not difficult, but you would expect to delegate exactly that kind of work to the machine/automated code assistants. I could only guess that maybe it mixes C#-.NET-Framework snippets with C#-.NET-Core code snippets.
GHC does not understand C# syntax well. It inserts code snippets into your VS2022 code project, but it messes with the open/closed curly brackets of code blocks. You need to count them by yourself and add/remove what is needed. Wastes your time and sometimes creates quite a mess. Such a disappointment that the generated code is not immediately compilation-ready.
GHC does not understand C# methods/properties well. It offers me code that looks nice, and I accept it. But C# class object does not have that method at all. It was close, its parent object has that method, so I figured that by myself. OK, it was close, and put me on the right track. But that is what machines are supposed to be for. No human can remember all the methods from maybe 10.000 C# classes that are .NET8 API that I use in my coding. I would expect the machine to help me with that. But, no, even GHC is not sure what method is on which class. It gives you a small homework to check that manually by yourself. The code it gives to you will not compile, but is “close”. It looks like GHC hallucinates that the C# class has some method, but it doesn't.
GHC does not understand C# methods/properties well. I am using EF8 in my VS2022 project, and have a class Customer. I started to write some access method to the Customer DB-table, and GHC offers me GetCustomer method prediction in the “ghost text”. Concept is solid, and yes, that DB-table has a Primary Key, but it is NOT called CustomerId. It looks like GHC simply hallucinates that such a class property with that name should exist, but it doesn’t. Predicted code will not compile, and I need to go check into the class Customer what is exactly the exact name of the Primary Key is. It is such a disappointment that a machine/automated code assistant, GHC, can NOT check by itself proper property/method names. It is just another class in the VS2022 project. So, the code snippet is conceptually close, but I need to fix manually by myself syntax errors. And I had such a situation 100+ times.
GHC does not understand C# methods/properties well. Impression is that GHC is shallow, it does not see much more than a few pages of code, and it is trying to “guess out” what the rest of the VS2022 project looks like.
GHC chats tend to waste your time. It wastes your time with its guesses. I do not have time to read more than 2 proposals of generated code. I need to do some work. After 1-2 wrong guesses, I ignore GHC and write code by myself. I tried to “chat with GHC” and sometimes after 5-7 chat interactions, it will still be as stupid as at the beginning of the conversation. Feels like talking to a non-AI chatbot on some site selling tickets. It repeats its text all the time, and GHC has NO FOCUS on what you really need. I tried that approach a few times, to “refine” my request in interactive chat, but it feels like talking to an idiot. I do not do that anymore, I respect and save my time and energy. I ignore GHC and do some straight coding and get results old-fashioned way. So, the conclusion is: I give GHC 1-2 chances to say what it has to say, then ignore it so as not to waste my time, and do coding manually.
GHC chats tend to waste your time. GHC is not always a good source of information. It can be brilliant and give you better info and code samples than you hoped for. But there is UNCERTAINITY. It can fail. If you try to get advice on some very common topic, just a bit specific to your needs, it will waste your time in endless chat sessions. Better go to Google and find an article on Stack Overflow by yourself. GHC is a text generator, and that machine can generate a huge amount of text and code samples as a response to your question. I was overwhelmed with the quantity of code samples it gives you. For a question you ask, it gives you text and code samples that require maybe 15 minutes to read and understand. It is almost as if it is assigning you a task: read this, and then we will talk again. And that answer after answer. That GHC thing can do that forever, to coach you how HTTP works, for example, and you ask about just one header. The problem is, it does not have focus, that is not what I asked. All that is off-topic garbage. It is faster to go to Google and filter/open a couple of links to find the answer to your problem. So, the conclusion is: I ask GHC and read 1-2 answers, then go to Google, not to waste my time.
GHC does not follow user instructions closely. It looks like GHC does not follow closely user's instructions closely, it thinks it is smarter than the user, and it follows instructions loosely, and gives what it thinks is better for the user. So, I want HTML ASP.NET Razor form created in a certain way/style uniform across the application, but not with GHC, when I tell that, it still gives me a HTML form like from the textbook. That happened in other situations as well.
GHC feedback form is a waste of time. So, software companies have a brilliant idea: they will charge for the product, but at the same time kindly ask users to participate for free in product testing. So, like many other products, some dialogs pop up asking you for your feedback. The question is whether anyone will read what you write, even if you fill the form. So many products are popping up dialogs telling you about new features and asking for 5-star evaluations of every result they produce, or even written comments. Such dialogs just clutter my workspace, and I typically have more serious things to do than to answer several questions evaluating each and every service I got. Basically, they want users in mass to help train their AI system by evaluating each answer.
GHC excels in small, limited scope tasks. I needed a method to Trim() all the strings in the EF class; I wanted a generic solution. I knew Reflection was the way to go, but in one line command request, GHC generated me the perfect 30-line method. Those are situations where GHC can not be beaten by humans. It would take me time to find the proper Reflection method, read some APIs, etc. This way, I got it in 20 seconds. But, GHC is sometimes brilliant, sometimes useless even in such scenarios.
GHC fails in a bit elaborate JavaScript task. So, I had a simple problem, limited scope, I needed a 10-liner method to wait until jQuery has been loaded, because I was using the “defer” attribute on jQuery loading. Looked like a perfect task for GHC. But I was shocked. Even after 5 attempts, GHC was producing some JS code that is doing something else. It could not understand what I wanted. It was just keeping generating some snippets that are seemingly related to the problem, but in reality were useless. Like you gave a task to a Junior programmer who “claims” to know some JS, and it keeps bringing you random code samples he finds on the internet, but no one is doing the simple thing you asked for. Later, I found a snippet on StackOverflow by myself. Maybe 3 clicks on Google and I found it. GHC is so inferior sometimes.
GHC produces shallow C# comments. I was using GHC to add some comments to my methods, and the produced comments are a bit shallow; they do not see the big picture of what that method is trying to achieve. That is more important than line-by-line comments, now we assign this or that. It can infer from English names of methods the purposes of the method, but still not very impressive most of the time.
GHC doesn’t understand C# comments well. GHC, when asked to create comments for a method, can erase some lines of real code. Be careful and read carefully what is given to you as an answer. It is a big pain, you need to manually re-read the whole method, and you can not trust GHC. It looks like GHC does not understand syntax well, and what is a comment or not, it sees just text. It happened to me, and I looked very carefully at why. I had some property set, and in the comment above, it was an old setting that I tested and commented out. The GHC thing erased both of them, the code and the old code commented. There is a probability that I have such a thing at many places in the code. So, high risk of unwanted code manipulation for a simple request to just add some comments. All generated commented code needs to be reviewed manually.
GHC “context” story doesn’t work as advertised. It looks like there is a “blame” game going on, with Tech companies pointing the finger at developers for failures of the AI-Gen products. Simply, current Gen-AI tools are not as useful as advertised in real-life situations. But there is a huge “sales effort” to sell the current generation of AI tools, however imperfect they are, and to generate some revenue NOW. So, for failures and limitations, finger-pointing is going in the direction of users: “tools are great, you just do not know how to use them”. Tech companies say: It is the user's failure when AI tools fail, not true that current AI tools have problems. One such blame game is the “context” setup for GHC.
GHC “context” story doesn’t work as advertised. I am tired of reading/listening to: “you didn’t specify CONTEXT well enough”. That is just an excuse, because I did follow all the advice, and the GHC thing is still stupid and wasting my time generating useless code snippets that do not even compile, not to mention that they are off topic. I was reading about “prompt engineering” and “context”, but after my best effort, I believe that GHC thing is not smart enough, and can’t do the job. Let’s wait for 6 months and try newer tools. It is a waste of time to try to squeeze more from GHC at this time. So, the truth is that at the present time (March 2025), GHC is quite stupid and no amount of “context info given” can help it to solve the intermediate level task.
GHC can’t solve a simple Exception. I had code throwing an exception and wanted to use GHC to solve it. I positioned on the Exception in Visual Studio and invoked GHC with /FIX. It was generating text, including a recommendation to “log more to better understand code defects”, but no specific answer. It was easy, I just copied the Exception text into Google, and 3^rd link was the explanation. Not to mention that there was more text on Google on why EF9 is failing, etc. GHC can be so inferior in regular tasks.
GHC can’t enumerate properties from the plain C# class. I was doing some LINQ and copied some objects from classes that inherit from each other. I wanted to copy all the properties that match. There were like 25 properties. I started assigning 2-3 properties and hoped for GHC to pick the pattern and insert code for the rest. No, it wouldn’t. It added a few properties out of order (which is a problem, you cannot follow which are added and which are not), then invented names of a few properties that do not exist (hallucinate?), and it was stacked. I was trying to issue commands from the command prompt, but it misunderstood me, inserted the whole C# class in place, etc. I was trying that several times in different places, because I have many big DTOs, so such copying is often the task. I could not make it do it for me. I got bored and copied properties manually by myself. I was tired of giving instructions to a seemingly stupid tool. Strange that you cannot delegate such a simple task to GHC. At times, IntelliSense is much smarter and useful than GHC.
GHC can’t do a little project of 4 C# files. So, I was eager to use generative AI in my VS2022/C# project and was looking for the right opportunity. I noticed one, I was creating HTML/Razor/ASP.NET8/Bootstrap views that present some HTML tables corresponding to DB tables. It was a bit elaborate; there was breadcrumb UI inside the view, some AJAX, etc. So, I manually made one MVC Action/View for the Customers table and wanted to do completely the same for Contracts. All the same, just another DB table (corresponding to EF8 class), another EF class name with new properties. The HTML table I wanted to generate was supposed to look the same, Bootstrap style. So, typical “follow the PATTERN in 4 files problem”. I have seen several videos emphasizing the importance of the “context”. So in a separate text editor, I started to write precise instructions for GitHub Copilot. I explained the task, said which file I want as a template, and marked the file name with #. I explained where the MVC model will come from, which file, etc. I even spell-checked my small paragraph task for GHC. I spend some time preparing task instructions in a clear manner. Then I supplied it to the GHC. The first form it generated did NOT follow the template I explicitly mentioned. GHC thing gave me something like a textbook-looking HTML form, not one customized in Bootstrap for my application. I asked for a new generation of code files. The second one looked like the form I already created, but out of 15 DB table properties, it created only 4. Later, I figured GHC can NOT read dependent files and is most of the time guessing property names. It guessed right because I was disciplinarily following the same naming conventions in different EF classes, so guesses by GHC worked. I finished the file manually, by manually adding 10+ missing properties. One would expect that such a repetitive task could be delegated to the GHC, but no, GHC can NOT do the simple repetitive job.
GHC can’t do a little project of 4 C# files. I tried again similar situation of generating some files in my VS2022/C# project based on a clear pattern-prototype file. Results are not very good, although that was the situation that was as advertised, arranged for GHC to succeed. Not complicated logic, clear name replacement needed, just a bit complicated HTML table corresponding to another DB table. But, it looks like GHC can not read EF8 properties from a 3^rd file and enumerate them to create a similar-looking HTML table. Also, it introduces a lot of errors into the generated file, by hallucinating about C# properties. Sometimes even changes the file code without reason, so a line-by-line manual check of the generated file is needed. Also, command line chatting to GHC and asking for changes consumes time, and since the result is not guaranteed and contains errors, in the end is not an efficient way of software development.
GHC can’t do a little project of 4 C# files. Looking back, I could not be more precise regarding “context” specification. Any person would understand the given written task and the context specified. I concluded that GHC is just not smart enough to handle a small generation of 4 files, even when given a very template/pattern-oriented task. I do not want to hear anymore “proper context” stories, because I put an effort to do everything right. And it is a waste of time and effort to go and ask GHC to generate files again and again and re-read every new generated code in my VS2022/C# project. I tried that, and GHC can generate another file every time you ask, and I was tired of looking into failed attempts.
GHC can’t do a little project of 4 C# files. Now, when I have a similar situation to generate a new HTML view based on the template I have, a pattern-based task, I do not ask GHC anymore. I just use a text editor with Find/Replace, in my VS2022/C# project and it is the same amount of time and with more certainty. Because when I use Find/Replace, I know exactly what I am getting, and GHC thing would change strings, but on its own initiative, do some changes to code sometimes, so I was never sure if it changed or erased a line or two of original template code. It is boring work, but no unexpected surprises from “smart” GHC “improving” my code.
GHC makes silly Bootstrap mistakes. I couldn’t remember Bootstrap class names, and I wanted to enlarge the button left and right. I asked GHC and it gave me Bootstrap class names. I applied them, and it enlarged the button top and bottom. Strange, how it can make such a mistake. I needed help exactly with all the Bootstrap CSS classes, I can not memorize them all. That is such a simple question, and GHC can not do it.

6 How to describe AI systems like GitHub Copilot

A typical good definition of something new consists of 2 parts: 1) the object/concept it is similar to, and 2) how it is different from a similar object/concept.

So, when talking about Intelligent systems, people usually take humans as a reference value. They tend to say: AI-Gen system is on the level of a Junior programmer, but is better/worse in this or that.

But I feel that for AI systems like GitHub Copilot (GHC), humans are not a good reference. Humans gradually progress in their intellectual ability, they have the ability first to solve simple tasks, then more complicated and so on.

I do not know much about autism, except for Hollywood movies like “Rain Man” (1988) with Tom Cruise. But if we are to compare GHC to humans, GHC looks like that autistic character from the movie. It can be brilliant and solve complex puzzles fast, but it can fail on a very simple task.

I would put AI systems like GHC in their own category. Their speed and huge memory, and ability to generate a huge amount of text/code fast make them incomparable to humans. That is like an idiot that has memory and mathematical ability a million times better than any human, but is still an idiot in front of the simple problem. Can you call it stupid because it does not “write code logically” but instead probably searches millions of lines of code in its memory and finds the solution to the problem faster than you?

7 After the experience, how am I using GitHub Copilot now

7.1 GitHub Copilot makes many C# mistakes

Regarding code-assisted generation, GHC is such a huge disappointment that it can not get the C# syntax right all the time and check the existence of C# properties/methods by itself. That is definitely not what one expects to see from a machine. My feeling is that it can not reason logically at all, otherwise, it would be able to follow simple syntax rules all the time, and not create a mess with extra brackets or hallucinate about non-existing C# class methods or properties.

A big shock was when GHC was asked to add comments, it deleted the active line of code because a similar line of code was commented out. That GHC thing does not fully understand what is “active line of code,” otherwise it would not delete it. It seems it just sees text of some kind, and generates “look-alike” text. More like a child with huge memory and speed toying with code, than a “pair programmer” or a “peer programmer” as it is advertised.

7.2 When to use GitHub Copilot

So, I have coding tasks to do, and toying with GHC was fun, but now it is time to be serious. My time is limited, and my energy needs to be focused productively.

I use “ghost test” from GHC a lot, review it, and accept suggestions when I like them. It does not waste my energy, text just pops up in my VS2022/C# project, sometimes it is useful, other times it can be interesting to see what AI thinks I should do now, and it's a bit of fun to read AI suggestions.
I select a part of code in one file in my VS2022/C# project, and ask for some changes or comments. GHC can understand such tasks well. I focus on a limited number of lines, maybe 50, and ask for suggestions. Sometimes GHC suggestions are useful, but many times it can not understand what I want or produces incorrect answers. It can be lost even after 3-4 iterations of chat prompts about a simple question like which specific Bootstrap CSS class I need. But, I have it all under control, and it does not waste my time much. If it doesn’t know the answer well, I go to Google for the resolution.
I use the GHC text-prompt page to ask for the generation of snippets or small functions with clear functionality. GHC is great for such tasks. Here, it can be really brilliant at times, but sometimes it gives code snippets that are the wrong answer. No guarantees GHC will succeed here, but if it does, it can be brilliant.
I no longer try bigger changes involving 3-4 files at the same time, since it is a pain and effort to chat with GHC to do that. Even worse, the code generated after EACH GHC intervention needs to be re-read since one is never sure what else GHC will change. Using GHC for such tasks is a waste of my time. Answers are at best incomplete, with many errors, like C# properties and methods that do not exist (it hallucinates?). It does not follow the given pattern closely, so I need to carefully read the generated code in my VS2022/C# project, since it can delete a line of code or add some code of its own, which is wrong in this particular case. Also, it is time and energy-consuming to REVIEW each answer GHC provides, and that is a machine that can generate new iterations of sample code forever. And I am just a human, I might need maybe 10 minutes of full focus to review 300 lines of combined C#/Razor/CSS/JS, which GHC generates in 2 seconds. And if I ask it to regenerate an answer, that is to give me a new proposed solution, I need to REVIEW it all again from the beginning.
I was thinking, why does it hallucinate about C# properties and methods that do not exist for well-known and frequently used APIs, like related to Http context, etc.? Maybe it copied a snippet from.NET4.8 Framework, and that method is no longer there for .NET Core… But, for C# classes that are part of my VS2022 project, like EF8 classes, it looks it does not read them, it just tries to guess, there must be a Primary Key with the name CustomerId, but it is actually called differently, so I need to manually open EF8 class and copy-paste proper names of the properties.
I do not believe in “proper context” story, but believe simply that the tool GHC is not smart enough to do serious work, and it is faster to code things straight than to endlessly chat with GHC.
That “proper context” story is a blame game by companies producing AI tools, trying to blame developers for not being able to use AI products properly. So, I have learned enough about “prompt engineering” and was making a serious effort to exploit GHC to generate code for me in my VS2022/C# project, but failed. I even planned to use GHC for tasks that suit it, to follow patterns I made (like HTML tables) and generate analogous code, but no, GHC was not good enough. Altogether, it generates more mess than useful code, for assigned pattern-based tasks involving 4 files.
I returned to the old method of handling UI patterns files. For example, to create “ListOfContracts” HTML (quite advanced AJAX form) based on a very similar “ListOfCustomers” UI form. I copy and rename the file. Then I use a text editor Find-Replace to modify the form in my VS2022/C# project. It is slow, but there is a certainty in progress, and no nasty surprises with missing lines of code or added unexpected lines of code. I was thinking I would use GHC for such pattern-looking tasks, but it is more time-efficient and energy-efficient to code it directly manually.
I ask GHC for help with problems, but read max 2 chat replies. Its answers tend to be verbose, and if it knows it, I will get an answer in 2 attempts, which can be brilliant at times. If it does not give me a good answer in 2 attempts, I will go read Google for the same problem. That GHC thing can generate a huge amount of text and code samples and coach you on nice things, but I have a specific problem to solve, not time to chat endlessly. GHC has a serious focus problem, answers are frequently off-topic.

8 Marketing for AI products is very strong

Marketing for AI products by tech companies is very strong, so one must put in an effort to stay grounded regarding the abilities of AI products in the present moment of time.

Marketing is strong, because Tech companies have put money into it and want some sales and revenue NOW. Even if actual AI products are not “production-ready”, they want to sell them on a “vision story”. Just to collect he money, marketing will create any story it needs. A good story that sells does not need to accurately reflect technical reality.
They are talking about “pair programming”, meaning you will not work alone but in “pair”, there will be 2 of you working, you and an AI-guy like GHC. Maybe in the future, but as of March 2025, I see GHC as just another code-assistance tool.
They are talking about “peer programming”, meaning AI-guy will be equal to you in your task. As of March 2025, GHC is still having big problems with C# syntax and hallucinates a bit of what some .NET Core API C# class precisely looks like. It can’t read the file in the VS2022 project that is there, but instead, GHC gives a human task to check syntax and finish its work, while it should be the opposite; humans should delegate such boring tasks to AI tools.
To make developers feel good about themselves, there are imaginative marketing stories created about “piloting and aircraft” and “having a copilot”. At the end of the day, you are just a guy in front of a keyboard and monitor, not in a fancy airplane traveling the world. And that GHC “AI buddy” you have (as of March 2025) looks a bit autistic to me, talks much, sometimes brilliant, sometimes stupid, and better check everything he does/says because it may sound like he knows it, but can be wrong.
Many AI-code generators are being demoed publicly in a bit of arranged, non-realistic scenarios. They limit the demo to a generation of a small 50-line function, like “factorials” or “Fibonacci numbers”. These are well-known programming textbook tasks. AI systems excel in math and might even just pull a code sample from their huge memory of code snippets. Such demos do not show how such systems would hold up when faced with real-life 300+ files of code software development projects.

9 Conclusion

GitHub Copilot (GHC) (as of March 2025) is a useful tool, and I will continue to use it in my programming. It does save me a measurable amount of time by providing code snippets and suggestions sometimes.

The technology level currently is that GitHub Copilot (GHC) can not be trusted with a bit complicated task involving several files at the same time. In such scenarios, results are incomplete and not time-efficient compared to direct manual programming.

A serious problem is that GitHub Copilot (GHC) tends to hallucinate about C# methods and properties that do not exist. The GHC-generated code does not compile right away, requiring a lot of manual work to finish it.

Things are evolving quickly, so the notes above are already almost outdated—apparently, a new tool called GPT-4o was released just a few days ago. It seems that AI tech companies are quietly upgrading these tools in the background, making them better and better without users receiving any explicit notice.

Some reports in the media suggest that large language models (LLMs) have reached their maximum and that by pure scaling, they are not becoming better. Maybe we will need to wait for some theoretical progress in AI science before we see real progress with AI tools.

Version of GitHub Copilot from March 2025 is useful, though not as great as advertised. We can expect that over time it will become better. But, still needs to be seen/verified in reality.

At the end, of course, ask for a second opinion on everything that was said in the article above.

Portable Monitors for Laptops Are Surprisingly Affordable

Mark Pelf — Thu, 27 Feb 2025 07:21:32 +0000

In this review, we evaluate a 15.6-inch portable monitor with a 1920x1080 resolution, purchased for 36 Euros.

Abstract: I bought a 15.6-inch portable monitor (1920x1080) from Temu.com for 36 Euros. After testing, I found the quality to be excellent, with well-thought-out design features.

1 Digital Nomads and Their Gadgets

While browsing Temu.com, I came across a 15.6-inch portable monitor (1920x1080) priced at 36 Euros, including shipping. The price caught my attention, and after checking customer reviews— all of which were positive— I was intrigued. A monitor at such a low price seemed almost too good to be true. After a few days of consideration, I decided to order one. Given the price, the risk was minimal.

Product Details:

Brand: Shenzhen Monitor Factory
Model: NC156A
Specifications: 15.6" Portable Monitor, 1920x1080
Price: 36 Euros (including shipping)
Seller: Temu.com

2 Package Arrival

The monitor arrived in 13 days via mail. The packaging was excellent, comparable to well-known brands. The box included an instruction manual— though the English was sometimes unusual, it was detailed enough for setup. Interestingly, customer support uses a Hotmail.com email address. They sent some “panda stickers” too, as a symbol of China. I see no difference in packaging compared to some brand name like HP, only the manual would be a more classy.

Here is what was in the box:

3 Examining equipment and Setup

Upon inspection, the build quality looked impressive. The monitor included two stand options:

A plastic standalone stand
A plastic-magnetic folder stand

If this were a well-known brand like HP, people would praise the "great design". Now, they are saying “they copied someone else’s design”. Regardless, the design works well.

Device offers 2 ways of connecting the laptop, for new laptops, a single USB-C cable for signal and power. For older laptops, HDMI for signal, with power from a classical USB-C power adapter.

In both cases, I successfully connected the monitor to my laptop and set up dual-screen functionality on Windows 11.

4 Image Quality

The main question: How good is the display?

To test this, I created a typical developer/debugging setup. The image quality is comparable to my laptop’s display, providing clear and sharp visuals for everyday tasks.

Given its 15.6-inch size, content appears slightly smaller but remains readable.

5 Conclusion

My first impressions of this monitor are very positive. If the same hardware had an HP or Dell logo and was priced around 100€, I would still consider it a great purchase.

Interestingly, there is no brand or logo on the monitor, packaging, or manual. Despite this, I’m impressed enough with the product that I would gladly look for others from the same company, even at a higher price in the future. However, it appears to be an unbranded, no-name product.

However, long-term durability remains to be seen. Only time will tell if any defects arise.

Entity Framework 9 - GroupBy throwing Exception

Mark Pelf — Tue, 18 Feb 2025 15:26:21 +0000

EF9 has a bug and gives an exception "The given key 'EmptyProjectionMember' was not present in the dictionary".

Abstract: Regular usage of EF9 sometimes throws Exception "The given key 'EmptyProjectionMember' was not present in the dictionary". It seems that is related to the bug in EF9 related to the usage of GroupBy.

1 EF 9 has a bug related to GroupBy usage

I am using Microsoft.EntityFrameworkCore (9.0.2).
In my code I am using GroupBy like this

 var query2 = query
             .GroupBy(contract =>
                             new { contract.BC_NR, contract.VERTRAGS_NR, contract.VERTRAGS_TYP }
                           )
             .Where(group => group.Any())
             .Select(group =>
                     group.OrderByDescending(contract => contract.CHANGE).First()
                    );

That is working fine, when I materialize the query.
But, if I after that do some sorting, it throws Exception.


var thisWorksFine = iQueryableTBS_VERTRAG2.ToList();
iQueryableTBS_VERTRAG2=iQueryableTBS_VERTRAG2.OrderBy(p=>p.VERTRAGS_NR);
var thisThrowsException = iQueryableTBS_VERTRAG2.ToList();

//Exception: The given key 'EmptyProjectionMember' was not present in the dictionary.

It can be seen in [1] that other people report the same issues. Obviously, that looks like a serious limitation of EF9, or better to say "a bug".

2 Some workarounds tried

There was some unusual workaround suggested on the internet, so I wanted to try it.


var thisWorksFine = iQueryableTBS_VERTRAG2.ToList();
string text22 = iQueryableTBS_VERTRAG2.ToQueryString();
iQueryableTBS_VERTRAG2= ctx.TBS_VERTRAG.FromSqlRaw(text22).AsNoTracking();
var thisStillWorksFine = iQueryableTBS_VERTRAG2.ToList();

iQueryableTBS_VERTRAG2 =iQueryableTBS_VERTRAG2.OrderBy(p=>p.VERTRAGS_NR);

var thisThrowsAnotherException = iQueryableTBS_VERTRAG2.ToList();

//Exception: 'FromSql' or 'SqlQuery' was called with non-composable SQL 
//and with a query composing over it. Consider calling 'AsEnumerable' 
//after the method to perform the composition on the client side.

So, that workaround would not work in my case. The problem is that generated SQL in my case contains parameters definitions and the resulting query is not composable. Semicolons are the problem. Here is what my generated SQL looks like, the content of variable text22:

DECLARE @__bankClearing_0 int = 1;
DECLARE @__bankClearing_1 int = 1;

-- Contracts_ContractsListDT

SELECT [t7].[BC_NR], [t7].[VERTRAGS_NR], [t7].[CHANGE], [t7].[VERTRAGS_TYP], [t7].[AENDERUNG], 
[t7].[ARCHIV_BEZ1], [t7].[ARCHIV_BEZ2], [t7].[ARCHIV_BEZ3], [t7].[AUSZUEGE_BIS_VORTAGE], 
[t7].[BERATER_NR], [t7].[CONTRACT_COLLECTION], [t7].[DOCUMENT_BOX], [t7].[ERFASST_DURCH], 
[t7].[ERFOLGLOS_Z], [t7].[ERSTELLT], [t7].[FREIGABE1], [t7].[FREIGABE2], [t7].[FREIGABE_DATUM_1], 
[t7].[FREIGABE_DATUM_2], [t7].[GESPERRT], [t7].[GESPERRT_BIS], [t7].[GESPERRT_VON], 
[t7].[GLAEUBIGER_ID], [t7].[GLAEUBIGER_ID_LONG], [t7].[KUNDEN_NR], [t7].[LASTMOD], [t7].[LAST_CALL], 

......

3 No better practical known workaround

Article [1] mentions some other workarounds, but they didn't look practical to me. I simply coded again my EF query to avoid the usage of GroupBy, even that approach might resulted in an ugly and slower query.

4 Bug in EF 9 expected to be fixed in EF 10

In article [1] person called Shay Rojansky, a member of the Entity Framework team at Microsoft, promises that the bug will be fixed in EF 10.
According to [2], the next planned stable release is EF Core 10.0, or just EF10, scheduled for November 2025.
So, until then, we are forced to do workarounds.

References

[1] https://github.com/dotnet/efcore/issues/31209

[2] https://learn.microsoft.com/en-us/ef/core/what-is-new/

Testing speed of modern External SSD backup

Mark Pelf — Thu, 26 Dec 2024 08:44:29 +0000

Practically testing speed in real environment of latest technology External SSD devices (December 2024).

Abstract: I decided to practically test the speed of the latest technology in External SSD devices and compare it to previously available technologies of External USB-based backup devices. Tests are done with real-life file sets and real commercial laptops used in typical company environments.

1 Need for External USB backup in the modern business environment

The need for safe, offline backup is driven by ransomware attacks, which I actually experienced in my company. However, there are also other kinds of needs to move files between workstations, home, and office computers, and there is a need to have backup in case of system crashes or accidental deletions.

For such situations External USB memory/disk devices are irreplaceable. I like them because I can attach them to make a backup and later detach them and physically move them to a safe place, where they are definitely offline.

My favorite backup method is very simple one: the usage of FreeFileSync app (high-quality freeware) that synchronizes directories. I keep all my work files on my work laptop in one root folder and sync periodically to an External USB device.

In compliance with company rules, I keep all my External USB devices BitLocker encrypted and secured with the password needed to access the device. There are many sensitive company and personal documents I have there, so I definitely want them safe in case memory/disk device is lost, for example during commuting to/from the office.

Over the years technology for External USB memory/disk backup changed, bringing always greater transfer speeds. I bought some latest External SSD-s, so I wanted to test them.

2 Test scenario setup

Here are the basic testing conditions:

I will use a new Lenovo laptop with the newest USB A and USB C ports
I will backup real life work files, around 49.4GB
I will backup them to the External USB memory/disk device of choice
External USB memory/disk device will be BitLocker encrypted
I will use FreeFileSync app (high-quality freeware) that synchronizes directories as a backup solution

Here are the specs for the ports of my laptop:

Here is the folder with real-life docs that I will backup:

3 Testing External 64GB USB Flash drive

Device info:

64GB USB Flash drive
Kinston DataTraveler 3.0 USB
USB-A, 3.0 (5Gbps)
49.4GB transferred in 97min 15sec
Average speed of backup 8.66MBps=69.26Mbps

4 Testing External 1 TB USB HDD

Device info:

External 1 TB USB HDD
Toshiba 1 TB HDD
USB-A, 3.0 (5Gbps)
49.4GB transferred in 22min 28sec
Average speed of backup 37.5 MBps=300 Mbps

5 Testing External SSD 1 TB, USB 3.2 Gen2

Device info:

External 1 TB SSD
Samsung PSSD T7 1TB
USB-C 3.2 Gen 2 (10Gbps)
49.4GB transferred in 4min 3sec
Average speed of backup 208 MBps=1664 Mbps

6 Testing External SSD 2 TB, USB 3.2 Gen2x2

Device info:

External 2 TB SSD
Samsung PSSD T9 2TB
USB-C 3.2 Gen 2x2 (20Gbps)
49.4GB transferred in 2min 38sec
Average speed of backup 320 MBps=2560 Mbps

7 Conclusion

So, here are actual practical speeds of backup in real-world situations:

These values are measured in these conditions:

used a new Lenovo laptop (December 2024) with the newest USB A and USB C ports
backup real-life work files, around 49.4GB, 41.000 files, 6.000 folders
External device BitLocker encrypted
used FreeFileSync app (high-quality freeware) that synchronizes directories as a backup solution

Installing additional SSD on LENOVO ThinkBook 16 G7 IML

Mark Pelf — Thu, 19 Dec 2024 06:05:44 +0000

Installing additional SSD on LENOVO ThinkBook 16 G7 IML

Instructions on how to install additional SSD on laptop LENOVO ThinkBook 16 G7 IML.

Abstract: Laptop LENOVO ThinkBook 16 G7 IML is coming with default installed SSD 1TB, and a slot for additional SSD. Here we are showing how to install additional SSD.

1 New Lenovo laptop

I bought a new laptop LAPTOP LENOVO ThinkBook 16 G7 IML WUXGA IPS, Ultra 7 155H, 32GB, 1TB SSD. Nice machine, 155H processor, 16 cores, 22 threads. I wanted to add an additional SSD: Samsung SSD 990 PRO 2TB.

2 Install steps

2.1 Remove 9 screws

2.2 Remove laptop back

Remove the laptop back. Be careful, the plastic is fragile and soft.

2.3 Locate laptop modules

2.4 Disconnect battery

2.5 Prepare additional SSD

2.6 Install additional SSD

2.7 Assemble laptop

Assemble it back in the reverse order.

3 Check if the installation is successful

3.1 Check from BIOS

Check that BIOS sees both old and new SSDs:

SSD1: (1TB) WD PC SN740 SDDPMQD-1T00-1101
SSD2: (2TB) Samsung SSD 990 PRO 2TB

3.2 Benchmark tests from Windows

I have no idea why those 2 benchmark tools give different results.

XSD Tools in .NET8 – Part10 – LiquidXMLObjects - Advanced

Mark Pelf — Fri, 08 Nov 2024 12:59:27 +0000

A practical guide to XSD tools available in .NET8 environment.

Abstract: A practical guide to XML and XSD tools available in .NET8 environment, focusing on generating and using C# classes to process some XML valid for some given XSD (technology as of September 2024).

1 Doing XML and XSD related work in .NET8

I was recently doing some work related to XML and XSD processing in .NET8 environment and created several proof-of-concept applications to evaluate the tools available. These articles are the result of my prototyping work.

1.1 List of tools used/tested

Here are the tools used/tested:

Visual Studio 2022
XSD.EXE (Microsoft license, part of VS2022)
XmlSchemaClassGenerator (Open Source/Freeware)
LinqToXsdCore (Open Source/Freeware)
Liquid XML Objects (Commercial license)

1.2 Articles in this series

For technical reasons, I will organize this text into several articles:

XSD Tools in .NET8 – Part1 – VS2022
XSD Tools in .NET8 – Part2 – C# validation
XSD Tools in .NET8 – Part3 – XsdExe – Simple
XSD Tools in .NET8 – Part4 – XsdExe - Advanced
XSD Tools in .NET8 – Part5 – XmlSchemaClassGenerator – Simple
XSD Tools in .NET8 – Part6 – XmlSchemaClassGenerator – Advanced
XSD Tools in .NET8 – Part7 – LinqToXsdCore – Simple
XSD Tools in .NET8 – Part8 – LinqToXsdCore – Advanced
XSD Tools in .NET8 – Part9 – LiquidXMLObjects – Simple
XSD Tools in .NET8 – Part10 – LiquidXMLObjects – Advanced

2 More theory about XML and XSD rules

Here is some more theory about XML and XSD rules.

2.1 Optional Xml-Element and Xml-Attribute

Optional: Does not need to be present in the XML.

For XSD Schema elements:

Optional: minOccurs="0" attribute ->In order to set a schema element as optional, you include the minOccurs="0" attribute

2.2 The Difference Between Optional and Not Required for Xml-Element and Xml-Attribute

Note the difference:

Optional: Does not need to be present in the XML.
Not Required: Does not need to have a value.

You can have any combination:

Optional + Not Required
Optional + Required
Not Optional + Not Required
Not Optional + Required

For XSD Schema elements:

Optional: minOccurs="0" attribute ->In order to set a schema element as optional, you include the minOccurs="0" attribute
Required: nillable="true" attribute ->In order to set a schema element as not required, you include the nillable="true" attribute.

String data types are not required by default, though you can force them to be required.

Other data types, such as Boolean, Integer, Date, Time, etc. are all required by default. In order to make one of these data types not required, you must set the nillable attribute equal to true for the element in the schema.

3 Examples of XML and XSD

Here are some sample XML-s and XSD-s I created for test purposes.

3.1 Advanced case

Please note that this example XML/XSD has an Optional and Not-Required Xml-Element. Read the comments inside for more details.

<?xml version="1.0" encoding="utf-8"?>
<!--SmallCompany.xsd++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++-->
<xs:schema attributeFormDefault="unqualified" 
           elementFormDefault="qualified" 
           targetNamespace="https://markpelf.com/SmallCompany.xsd" 
           xmlns:xs="http://www.w3.org/2001/XMLSchema">
    <xs:element name="SmallCompany">
        <xs:complexType>
            <xs:sequence>
                <xs:element name="CompanyName" type="xs:string" />
                <xs:element maxOccurs="unbounded" name="Employee">
                    <xs:complexType>
                        <xs:sequence>
                            <!--Name_String_NO is String NotOptional-->
                            <xs:element name="Name_String_NO" type="xs:string" />
                            <!--City_String_O is String Optional-->
                            <xs:element minOccurs="0" name="City_String_O" type="xs:string" />
                        </xs:sequence>
                    </xs:complexType>
                </xs:element>
                <xs:element maxOccurs="unbounded" name="InfoData">
                    <xs:complexType>
                        <xs:sequence>
                            <!--Id_Int_NO is Int NotOptional-->
                            <xs:element name="Id_Int_NO" type="xs:int" />
                            <!--Quantity_Int_O is Int Optional-->
                            <xs:element minOccurs="0" name="Quantity_Int_O" type="xs:int" />
                        </xs:sequence>
                    </xs:complexType>
                </xs:element>
            </xs:sequence>
        </xs:complexType>
    </xs:element>
</xs:schema>

<?xml version="1.0" encoding="utf-8"?>
<!--SmallCompanyAAA.xml+++++++++++++++++++++++++++++++++++++++++++++++-->
<SmallCompany xmlns="https://markpelf.com/SmallCompany.xsd">
    <CompanyName>SmallCompanyAAA</CompanyName>
    <Employee>
        <Name_String_NO>Mark</Name_String_NO>
        <City_String_O>Belgrade</City_String_O>
    </Employee>
    <Employee>
        <Name_String_NO>John</Name_String_NO>
    </Employee>
    <InfoData>
        <Id_Int_NO>11</Id_Int_NO>
        <Quantity_Int_O>123</Quantity_Int_O>
    </InfoData>
    <InfoData>
        <Id_Int_NO>22</Id_Int_NO>
    </InfoData>
</SmallCompany>

4 Using LiquidXMLObjects tool to create C# class

We focus in this article on the usage of LiquidXMLObjects tool to generate C# class from XSD file.

Here is the tool's basic info.


Tool name:  ============================
Liquid XML Objects

License============================ 
2 licenses:
1) Free Community Edition: Home Users and Students, XML Schema (size limited)
2) Commercial Product, Developer Bundle (Installed) $770.94 (perpetual license)

Where to get it============================
https://www.liquid-technologies.com/xml-objects

Install Instructions====================================
-a free trial which will expire 15 days after activation, after this time the product will continue to operate as the Free Community Edition.

Version============================
Liquid Studio - Community Edition 20.7.14.13112

Help============================
https://www.liquid-technologies.com/Reference/XmlDataBinding/xml-objects-introduction.html
====================================================    
Usage Examples===================                         
Instructions to generate C# class 
Using GUI - context right click on .xsd file
====================================

4.1 GUI

This commercial product has an impressive GUI to issue commands. Here is how C# classes are generated.

You use the right-click menu to invoke C# class generation

And here are the options I set for C# code generation.

5 Generated C# class

Here is the C# generated by the above tool based on the above presented XSD BigCompany.xsd.

///////////////////////////////////////////////////////////////////////////
//           Liquid XML Objects GENERATED CODE - DO NOT MODIFY           //
//            https://www.liquid-technologies.com/xml-objects            //
//=======================================================================//
// Dependencies                                                          //
//     Nuget : LiquidTechnologies.XmlObjects.Runtime                     //
//           : MUST BE VERSION 20.7.14                                   //
//=======================================================================//
// Online Help                                                           //
//     https://www.liquid-technologies.com/xml-objects-quick-start-guide //
//=======================================================================//
// Licensing Information                                                 //
//     https://www.liquid-technologies.com/eula                          //
///////////////////////////////////////////////////////////////////////////
using System;
using System.ComponentModel;
using System.Collections.Generic;
using System.Linq;
using System.Xml.Linq;
using System.Numerics;
using LiquidTechnologies.XmlObjects;
using LiquidTechnologies.XmlObjects.Attribution;

// ------------------------------------------------------
// |                      Settings                      |
// ------------------------------------------------------
// GenerateCommonBaseClass                  = False
// GenerateUnprocessedNodeHandlers          = False
// RaiseChangeEvents                        = False
// CollectionNaming                         = Pluralize
// Language                                 = CS
// OutputNamespace                          = XsdExample_Ver4.XSD2
// WriteDefaultValuesForOptionalAttributes  = True
// WriteDefaultValuesForOptionalElements    = True
// MixedContentHandling                     = TreatAsAny
// GenerationModel                          = Simple
//                                            *WARNING* this simplified model that is very easy to work with
//                                            but may cause the XML to be produced without regard for element
//                                            cardinality or order. Where very high compliance with the XML Schema
//                                            standard is required use GenerationModelType.Conformant
// XSD Schema Files
//    C:\TmpXSD\XsdExample_Ver4\Example01\XSD2\BigCompany.xsd


namespace XsdExample_Ver4.XSD2
{
    #region Global Settings
    /// <summary>Contains library level properties, and ensures the version of the runtime used matches the version used to generate it.</summary>
    [LxRuntimeRequirements("20.7.14.13112", "Free Community Edition", "M9WDQLWDQNEEVNLX", LiquidTechnologies.XmlObjects.LicenseTermsType.CommunityEdition)]
    public partial class LxRuntimeRequirementsWritten
    {
    }

    #endregion

}

namespace XsdExample_Ver4.XSD2.Xs
{
    #region Complex Types
    /// <summary>A class representing the root XSD complexType anyType@http://www.w3.org/2001/XMLSchema</summary>
    [LxSimpleComplexTypeDefinition("anyType", "http://www.w3.org/2001/XMLSchema")]
    public partial class AnyTypeCt : XElement
    {
        /// <summary>Constructor : create a <see cref="AnyTypeCt" /> element &lt;anyType xmlns='http://www.w3.org/2001/XMLSchema'&gt;</summary>
        public AnyTypeCt()  : base(XName.Get("anyType", "http://www.w3.org/2001/XMLSchema")) { }

    }

    #endregion

}

namespace XsdExample_Ver4.XSD2.Tns
{
    #region Elements
    /// <summary>A class representing the root XSD element BigCompany@https://markpelf.com/BigCompany.xsd</summary>
    [LxSimpleElementDefinition("BigCompany", "https://markpelf.com/BigCompany.xsd", ElementScopeType.GlobalElement)]
    public partial class BigCompanyElm
    {
        /// <summary>A <see cref="System.String" />, Required : should not be set to null</summary>
        [LxElementValue(0, "CompanyName", "https://markpelf.com/BigCompany.xsd", LxValueType.Value, XsdType.XsdString, MinOccurs = 1, MaxOccurs = 1)]
        public System.String CompanyName { get; set; } = "";

        /// <summary>A collection of <see cref="XsdExample_Ver4.XSD2.Tns.BigCompanyElm.EmployeeElm" /></summary>
        [LxElementRef(1, MinOccurs = 0, MaxOccurs = LxConstants.Unbounded)]
        public List<XsdExample_Ver4.XSD2.Tns.BigCompanyElm.EmployeeElm> Employees { get; } = new List<XsdExample_Ver4.XSD2.Tns.BigCompanyElm.EmployeeElm>();

        /// <summary>A collection of <see cref="XsdExample_Ver4.XSD2.Tns.BigCompanyElm.InfoDataElm" /></summary>
        [LxElementRef(2, MinOccurs = 0, MaxOccurs = LxConstants.Unbounded)]
        public List<XsdExample_Ver4.XSD2.Tns.BigCompanyElm.InfoDataElm> InfoData { get; } = new List<XsdExample_Ver4.XSD2.Tns.BigCompanyElm.InfoDataElm>();

        /// <summary>Represent the inline xs:element Employee@https://markpelf.com/BigCompany.xsd.</summary>
        [LxSimpleElementDefinition("Employee", "https://markpelf.com/BigCompany.xsd", ElementScopeType.InlineElement)]
        public partial class EmployeeElm
        {
            /// <summary>A <see cref="System.String" />, Required : should not be set to null</summary>
            [LxElementValue(0, "Name_String_NO", "https://markpelf.com/BigCompany.xsd", LxValueType.Value, XsdType.XsdString, MinOccurs = 1, MaxOccurs = 1)]
            public System.String Name_String_NO { get; set; } = "";

            /// <summary>A <see cref="System.String" />, Optional : null when not set</summary>
            [LxElementValue(1, "City_String_O", "https://markpelf.com/BigCompany.xsd", LxValueType.Value, XsdType.XsdString, MinOccurs = 0, MaxOccurs = 1)]
            public System.String? City_String_O { get; set; }

        }

        /// <summary>Represent the inline xs:element InfoData@https://markpelf.com/BigCompany.xsd.</summary>
        [LxSimpleElementDefinition("InfoData", "https://markpelf.com/BigCompany.xsd", ElementScopeType.InlineElement)]
        public partial class InfoDataElm
        {
            /// <summary>A <see cref="System.Int32" />, Required</summary>
            [LxElementValue(0, "Data1_Int_NO_R", "https://markpelf.com/BigCompany.xsd", LxValueType.Value, XsdType.XsdInt, MinOccurs = 1, MaxOccurs = 1)]
            public System.Int32 Data1_Int_NO_R { get; set; }

            /// <summary>A <see cref="System.Int32" />, Required</summary>
            [LxElementValue(1, "Data2_Int_NO_NR", "https://markpelf.com/BigCompany.xsd", LxValueType.Value, XsdType.XsdInt, MinOccurs = 1, MaxOccurs = 1)]
            public LxNillable<System.Int32> Data2_Int_NO_NR { get; set; } = LxNillable<System.Int32>.Create(default(System.Int32), false);

            /// <summary>A nullable <see cref="System.Int32" />, Optional : null when not set</summary>
            [LxElementValue(2, "Data3_Int_O_R", "https://markpelf.com/BigCompany.xsd", LxValueType.Value, XsdType.XsdInt, MinOccurs = 0, MaxOccurs = 1)]
            public System.Int32? Data3_Int_O_R { get; set; }

            /// <summary>A nullable <see cref="System.Int32" />, Optional : null when not set</summary>
            [LxElementValue(3, "Data4_Int_O_NR", "https://markpelf.com/BigCompany.xsd", LxValueType.Value, XsdType.XsdInt, MinOccurs = 0, MaxOccurs = 1)]
            public LxNillable<System.Int32> Data4_Int_O_NR { get; set; }

        }

    }

    #endregion

}

Here is the class diagram.

6 Two C# API styles for Optional Xml-Elements

There are two approaches/styles for marking Optional Xml-Element presence in generated C# code:

The first is bool_flag_style – using a bool flag to indicate the presence of optional Xml-Element, with flag=false to indicate the Xml-Element was not present. For example, for some Xml-Element ElemA that, if present, will have value integer, you will get in C# generated two variables “bool ElemA_flag, int ElemA_value”. You need to check if element ElemA was present by first checking the flag ElemA_flag; and then if it is true, you go for the value of ElemA_value. If you do not check flag ElemA_flag first, and just go for the value of ElemA_value you might pick the default int value of zero (0), and you can not know if that is just the default value for C# variable that is always present, but Xml-Element was not present, or that element was present and it actually had the value of zero (0).
The second is nullable_type_style – using a nullable type to indicate the presence of Xml-Element, with value=null to indicate the Xml-Element was not present. For example, for some Xml-Element ElemA that, if present, will have value integer, you will get in C# generated variable “int? ElemA_nullableValue”. You need to check if element ElemA was present by first checking the ElemA_nullableValue not being null; and then if it is not meaning the element was present, you go for the int value of ElemA_nullableValue.

7 Sample C# app

Here is a sample C# code using the above generated C# class to load and process the above presented XML BigCompanyMMM.xml.

public static void ProcessVer4_Process2(
    string? filePath,
    Microsoft.Extensions.Logging.ILogger? logger)
{
    try
    {
        logger?.LogInformation(
            "+++ProcessVer4_Process2-Start++++++++++++++++++");
        logger?.LogInformation("filePath:" + filePath);

        LxSerializer<XsdExample_Ver4.XSD2.Tns.BigCompanyElm> serializer =
            new LxSerializer<XsdExample_Ver4.XSD2.Tns.BigCompanyElm>();
        TextReader textReader = File.OpenText(filePath ?? String.Empty);
        LxReaderSettings readerSettings = new LxReaderSettings();

        XsdExample_Ver4.XSD2.Tns.BigCompanyElm? xmlObject =
            serializer.Deserialize(textReader, readerSettings);

        if (xmlObject != null)
        {
            logger?.LogInformation("CompanyName:" + xmlObject.CompanyName);

            foreach (XsdExample_Ver4.XSD2.Tns.BigCompanyElm.EmployeeElm item in xmlObject.Employees)
            {
                logger?.LogInformation("------------");
                logger?.LogInformation("Name_String_NO:" + item.Name_String_NO);
                logger?.LogInformation("City_String_O:" + (item.City_String_O ?? "null"));
            }

            foreach (XsdExample_Ver4.XSD2.Tns.BigCompanyElm.InfoDataElm item in xmlObject.InfoData)
            {
                logger?.LogInformation("------------");
                logger?.LogInformation("Data1_Int_NO_R:" + item.Data1_Int_NO_R.ToString());
                logger?.LogInformation("Data2_Int_NO_NR:" + 
                    (item.Data2_Int_NO_NR.IsNil ? "nill" : item.Data2_Int_NO_NR.Value));

                logger?.LogInformation("Data3_Int_O_R:" + (item.Data3_Int_O_R?.ToString() ?? "null"));

                logger?.LogInformation("Data4_Int_O_NR:" + 
                    (item.Data4_Int_O_NR==null ? "null" :
                     (item.Data4_Int_O_NR.IsNil ? "nil" : item.Data4_Int_O_NR.Value)));
            }
        }
        else
        {
            logger?.LogError("xmlObject == null");
        }

        logger?.LogInformation(
            "+++ProcessVer4_Process2-End++++++++++++++++++");
    }
    catch (Exception ex)
    {
        string methodName =
            $"Type: {System.Reflection.MethodBase.GetCurrentMethod()?.DeclaringType?.FullName}, " +
            $"Method: ProcessVer4_Process2; ";
        logger?.LogError(ex, methodName);
    }
}

And here is the log of execution.

 +++ProcessVer4_Process2-Start++++++++++++++++++
 filePath:C:\TmpXSD\XsdExample_Ver4\Example01\bin\Debug\net8.0\XmlFiles\BigCompanyMMM.xml
 CompanyName:BigCompanyMMM
 ------------
 Name_String_NO:Mark
 City_String_O:Belgrade
 ------------
 Name_String_NO:John
 City_String_O:null
 ------------
 Data1_Int_NO_R:555
 Data2_Int_NO_NR:16
 Data3_Int_O_R:333
 Data4_Int_O_NR:17
 ------------
 Data1_Int_NO_R:123
 Data2_Int_NO_NR:nill
 Data3_Int_O_R:15
 Data4_Int_O_NR:nil
 ------------
 Data1_Int_NO_R:777
 Data2_Int_NO_NR:nill
 Data3_Int_O_R:null
 Data4_Int_O_NR:null
 +++ProcessVer4_Process2-End++++++++++++++++++

8 Analysis

This tool uses “nullable_type_style” approach/style to mark Optional Xml-Element presence in generated C# code. To enable the indication of “nill” it uses a special object class as a result.

Data1_Int_NO_R - is int type and always has value
Data2_Int_NO_NR - is an object of a certain class and can have 2 values:, 1) “nill”, 2)int. a) “nill”– present but “nill” b) int – present and had value
Data3_Int_O_R – is int? type and the meaning is 1) null - means it was not present 2) int – present and had value
Data4_Int_O_NR - is an object of a certain class and can have 3 values: 1)null, 2) “nill”, 3)int. 1) null – means the element was not present 2) “nill”– element was present but “nill” 3) int – element was present and had value

It is interesting to notice that this tool is using the modern API style/approach “nullable_type_style”. But, it still has the ability in the case of Xml-Element Data4_Int_O_NR to indicate all three states: “not-present”, “present-nill”, “present-int”. The way they achieve it is by using a special class/object to represent ternary value.

9 Conclusion

This tool LiquidXMLObjects is very interesting but requires a commercial license. The code generated looked solid in my test. It can be of great interest to users who want to use nullable_type_style API, which is generally a more modern approach for handling the Optional Xml-Elements.

The full example code project can be downloaded at GitHub [99].

10 References

[1] XML Schema

https://www.w3schools.com/xml/xml_schema.asp

[2] The Difference Between Optional and Not Required

https://www.infopathdev.com/blogs/greg/archive/2004/09/16/The-Difference-Between-Optional-and-Not-Required.aspx

[3] nillable and minOccurs XSD element attributes

https://stackoverflow.com/questions/1903062/nillable-and-minoccurs-xsd-element-attributes

[99] https://github.com/MarkPelf/XsdToolsInNet8

XSD Tools in .NET8 – Part9 – LiquidXMLObjects- Simple

Mark Pelf — Fri, 08 Nov 2024 12:57:53 +0000

XSD Tools in .NET8 – Part9 – LiquidXMLObjects- Simple

A practical guide to XSD tools available in .NET8 environment.

1 Doing XML and XSD related work in .NET8

1.1 List of tools used/tested

Here are the tools used/tested:

Visual Studio 2022
XSD.EXE (Microsoft license, part of VS2022)
XmlSchemaClassGenerator (Open Source/Freeware)
LinqToXsdCore (Open Source/Freeware)
Liquid XML Objects (Commercial license)

1.2 Articles in this series

For technical reasons, I will organize this text into several articles:

XSD Tools in .NET8 – Part1 – VS2022
XSD Tools in .NET8 – Part2 – C# validation
XSD Tools in .NET8 – Part3 – XsdExe – Simple
XSD Tools in .NET8 – Part4 – XsdExe - Advanced
XSD Tools in .NET8 – Part5 – XmlSchemaClassGenerator – Simple
XSD Tools in .NET8 – Part6 – XmlSchemaClassGenerator – Advanced
XSD Tools in .NET8 – Part7 – LinqToXsdCore – Simple
XSD Tools in .NET8 – Part8 – LinqToXsdCore – Advanced
XSD Tools in .NET8 – Part9 – LiquidXMLObjects – Simple
XSD Tools in .NET8 – Part10 – LiquidXMLObjects – Advanced

2 More theory about XML and XSD rules

Here is some more theory about XML and XSD rules.

2.1 Optional Xml-Element and Xml-Attribute

Optional: Does not need to be present in the XML.

For XSD Schema elements:

Optional: minOccurs="0" attribute ->In order to set a schema element as optional, you include the minOccurs="0" attribute

3 Examples of XML and XSD

Here are some sample XML-s and XSD-s I created for test purposes.

3.1 Simple case

Please note that this example XML/XSD has an Optional Xml-Element. Read the comments inside for more details.

<?xml version="1.0" encoding="utf-8"?>
<!--SmallCompany.xsd++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++-->
<xs:schema attributeFormDefault="unqualified" 
           elementFormDefault="qualified" 
           targetNamespace="https://markpelf.com/SmallCompany.xsd" 
           xmlns:xs="http://www.w3.org/2001/XMLSchema">
    <xs:element name="SmallCompany">
        <xs:complexType>
            <xs:sequence>
                <xs:element name="CompanyName" type="xs:string" />
                <xs:element maxOccurs="unbounded" name="Employee">
                    <xs:complexType>
                        <xs:sequence>
                            <!--Name_String_NO is String NotOptional-->
                            <xs:element name="Name_String_NO" type="xs:string" />
                            <!--City_String_O is String Optional-->
                            <xs:element minOccurs="0" name="City_String_O" type="xs:string" />
                        </xs:sequence>
                    </xs:complexType>
                </xs:element>
                <xs:element maxOccurs="unbounded" name="InfoData">
                    <xs:complexType>
                        <xs:sequence>
                            <!--Id_Int_NO is Int NotOptional-->
                            <xs:element name="Id_Int_NO" type="xs:int" />
                            <!--Quantity_Int_O is Int Optional-->
                            <xs:element minOccurs="0" name="Quantity_Int_O" type="xs:int" />
                        </xs:sequence>
                    </xs:complexType>
                </xs:element>
            </xs:sequence>
        </xs:complexType>
    </xs:element>
</xs:schema>

<?xml version="1.0" encoding="utf-8"?>
<!--SmallCompany.xsd++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++-->
<xs:schema attributeFormDefault="unqualified" 
           elementFormDefault="qualified" 
           targetNamespace="https://markpelf.com/SmallCompany.xsd" 
           xmlns:xs="http://www.w3.org/2001/XMLSchema">
    <xs:element name="SmallCompany">
        <xs:complexType>
            <xs:sequence>
                <xs:element name="CompanyName" type="xs:string" />
                <xs:element maxOccurs="unbounded" name="Employee">
                    <xs:complexType>
                        <xs:sequence>
                            <!--Name_String_NO is String NotOptional-->
                            <xs:element name="Name_String_NO" type="xs:string" />
                            <!--City_String_O is String Optional-->
                            <xs:element minOccurs="0" name="City_String_O" type="xs:string" />
                        </xs:sequence>
                    </xs:complexType>
                </xs:element>
                <xs:element maxOccurs="unbounded" name="InfoData">
                    <xs:complexType>
                        <xs:sequence>
                            <!--Id_Int_NO is Int NotOptional-->
                            <xs:element name="Id_Int_NO" type="xs:int" />
                            <!--Quantity_Int_O is Int Optional-->
                            <xs:element minOccurs="0" name="Quantity_Int_O" type="xs:int" />
                        </xs:sequence>
                    </xs:complexType>
                </xs:element>
            </xs:sequence>
        </xs:complexType>
    </xs:element>
</xs:schema>

4 Using LiquidXMLObjects tool to create C# class

We focus in this article on the usage of LiquidXMLObjects tool to generate C# class from XSD file.

Here is the tool's basic info.


Tool name:  ============================
Liquid XML Objects

License============================ 
2 licenses:
1) Free Community Edition: Home Users and Students, XML Schema (size limited)
2) Commercial Product, Developer Bundle (Installed) $770.94 (perpetual license)

Where to get it============================
https://www.liquid-technologies.com/xml-objects

Install Instructions====================================
-a free trial which will expire 15 days after activation, after this time the product will continue to operate as the Free Community Edition.

Version============================
Liquid Studio - Community Edition 20.7.14.13112

Help============================
https://www.liquid-technologies.com/Reference/XmlDataBinding/xml-objects-introduction.html
====================================================    
Usage Examples===================                         
Instructions to generate C# class 
Using GUI - context right click on .xsd file
====================================

4.1 GUI

This commercial product has an impressive GUI to issue commands. Here is how C# classes are generated.

You use the right-click menu to invoke C# class generation

And here are the options I set for C# code generation.

5 Generated C# class

Here is the C# generated by the above tool based on the above presented XSD SmallCompany.xsd.

///////////////////////////////////////////////////////////////////////////
//           Liquid XML Objects GENERATED CODE - DO NOT MODIFY           //
//            https://www.liquid-technologies.com/xml-objects            //
//=======================================================================//
// Dependencies                                                          //
//     Nuget : LiquidTechnologies.XmlObjects.Runtime                     //
//           : MUST BE VERSION 20.7.14                                   //
//=======================================================================//
// Online Help                                                           //
//     https://www.liquid-technologies.com/xml-objects-quick-start-guide //
//=======================================================================//
// Licensing Information                                                 //
//     https://www.liquid-technologies.com/eula                          //
///////////////////////////////////////////////////////////////////////////
using System;
using System.ComponentModel;
using System.Collections.Generic;
using System.Linq;
using System.Xml.Linq;
using System.Numerics;
using LiquidTechnologies.XmlObjects;
using LiquidTechnologies.XmlObjects.Attribution;

// ------------------------------------------------------
// |                      Settings                      |
// ------------------------------------------------------
// GenerateCommonBaseClass                  = False
// GenerateUnprocessedNodeHandlers          = False
// RaiseChangeEvents                        = False
// CollectionNaming                         = Pluralize
// Language                                 = CS
// OutputNamespace                          = XsdExample_Ver4.XSD1
// WriteDefaultValuesForOptionalAttributes  = True
// WriteDefaultValuesForOptionalElements    = True
// MixedContentHandling                     = TreatAsAny
// GenerationModel                          = Simple
//                                            *WARNING* this simplified model that is very easy to work with
//                                            but may cause the XML to be produced without regard for element
//                                            cardinality or order. Where very high compliance with the XML Schema
//                                            standard is required use GenerationModelType.Conformant
// XSD Schema Files
//    C:\TmpXSD\XsdExample_Ver4\Example01\XSD1\SmallCompany.xsd


namespace XsdExample_Ver4.XSD1
{
    #region Global Settings
    /// <summary>Contains library level properties, and ensures the version of the runtime used matches the version used to generate it.</summary>
    [LxRuntimeRequirements("20.7.14.13112", "Free Community Edition", "M9WDQLWDQNEEVNLX", LiquidTechnologies.XmlObjects.LicenseTermsType.CommunityEdition)]
    public partial class LxRuntimeRequirementsWritten
    {
    }

    #endregion

}

namespace XsdExample_Ver4.XSD1.Xs
{
    #region Complex Types
    /// <summary>A class representing the root XSD complexType anyType@http://www.w3.org/2001/XMLSchema</summary>
    [LxSimpleComplexTypeDefinition("anyType", "http://www.w3.org/2001/XMLSchema")]
    public partial class AnyTypeCt : XElement
    {
        /// <summary>Constructor : create a <see cref="AnyTypeCt" /> element &lt;anyType xmlns='http://www.w3.org/2001/XMLSchema'&gt;</summary>
        public AnyTypeCt()  : base(XName.Get("anyType", "http://www.w3.org/2001/XMLSchema")) { }

    }

    #endregion

}

namespace XsdExample_Ver4.XSD1.Tns
{
    #region Elements
    /// <summary>A class representing the root XSD element SmallCompany@https://markpelf.com/SmallCompany.xsd</summary>
    [LxSimpleElementDefinition("SmallCompany", "https://markpelf.com/SmallCompany.xsd", ElementScopeType.GlobalElement)]
    public partial class SmallCompanyElm
    {
        /// <summary>A <see cref="System.String" />, Required : should not be set to null</summary>
        [LxElementValue(0, "CompanyName", "https://markpelf.com/SmallCompany.xsd", LxValueType.Value, XsdType.XsdString, MinOccurs = 1, MaxOccurs = 1)]
        public System.String CompanyName { get; set; } = "";

        /// <summary>A collection of <see cref="XsdExample_Ver4.XSD1.Tns.SmallCompanyElm.EmployeeElm" /></summary>
        [LxElementRef(1, MinOccurs = 0, MaxOccurs = LxConstants.Unbounded)]
        public List<XsdExample_Ver4.XSD1.Tns.SmallCompanyElm.EmployeeElm> Employees { get; } = new List<XsdExample_Ver4.XSD1.Tns.SmallCompanyElm.EmployeeElm>();

        /// <summary>A collection of <see cref="XsdExample_Ver4.XSD1.Tns.SmallCompanyElm.InfoDataElm" /></summary>
        [LxElementRef(2, MinOccurs = 0, MaxOccurs = LxConstants.Unbounded)]
        public List<XsdExample_Ver4.XSD1.Tns.SmallCompanyElm.InfoDataElm> InfoData { get; } = new List<XsdExample_Ver4.XSD1.Tns.SmallCompanyElm.InfoDataElm>();

        /// <summary>Represent the inline xs:element Employee@https://markpelf.com/SmallCompany.xsd.</summary>
        [LxSimpleElementDefinition("Employee", "https://markpelf.com/SmallCompany.xsd", ElementScopeType.InlineElement)]
        public partial class EmployeeElm
        {
            /// <summary>A <see cref="System.String" />, Required : should not be set to null</summary>
            [LxElementValue(0, "Name_String_NO", "https://markpelf.com/SmallCompany.xsd", LxValueType.Value, XsdType.XsdString, MinOccurs = 1, MaxOccurs = 1)]
            public System.String Name_String_NO { get; set; } = "";

            /// <summary>A <see cref="System.String" />, Optional : null when not set</summary>
            [LxElementValue(1, "City_String_O", "https://markpelf.com/SmallCompany.xsd", LxValueType.Value, XsdType.XsdString, MinOccurs = 0, MaxOccurs = 1)]
            public System.String? City_String_O { get; set; }

        }

        /// <summary>Represent the inline xs:element InfoData@https://markpelf.com/SmallCompany.xsd.</summary>
        [LxSimpleElementDefinition("InfoData", "https://markpelf.com/SmallCompany.xsd", ElementScopeType.InlineElement)]
        public partial class InfoDataElm
        {
            /// <summary>A <see cref="System.Int32" />, Required</summary>
            [LxElementValue(0, "Id_Int_NO", "https://markpelf.com/SmallCompany.xsd", LxValueType.Value, XsdType.XsdInt, MinOccurs = 1, MaxOccurs = 1)]
            public System.Int32 Id_Int_NO { get; set; }

            /// <summary>A nullable <see cref="System.Int32" />, Optional : null when not set</summary>
            [LxElementValue(1, "Quantity_Int_O", "https://markpelf.com/SmallCompany.xsd", LxValueType.Value, XsdType.XsdInt, MinOccurs = 0, MaxOccurs = 1)]
            public System.Int32? Quantity_Int_O { get; set; }

        }

    }

    #endregion

}

Here is the class diagram.

6 Two C# API styles for Optional Xml-Elements

There are two approaches/styles for marking Optional Xml-Element presence in generated C# code:

The first is bool_flag_style – using a bool flag to indicate the presence of optional Xml-Element, with flag=false to indicate the Xml-Element was not present. For example, for some Xml-Element ElemA that, if present, will have value integer, you will get in C# generated two variables “bool ElemA_flag, int ElemA_value”. You need to check if element ElemA was present by first checking the flag ElemA_flag; and then if it is true, you go for the value of ElemA_value. If you do not check flag ElemA_flag first, and just go for the value of ElemA_value you might pick the default int value of zero (0), and you can not know if that is just the default value for C# variable that is always present, but Xml-Element was not present, or that element was present and it actually had the value of zero (0).
The second is nullable_type_style – using a nullable type to indicate the presence of Xml-Element, with value=null to indicate the Xml-Element was not present. For example, for some Xml-Element ElemA that, if present, will have value integer, you will get in C# generated variable “int? ElemA_nullableValue”. You need to check if element ElemA was present by first checking the ElemA_nullableValue not being null; and then if it is not meaning the element was present, you go for the int value of ElemA_nullableValue.

7 Sample C# app

Here is a sample C# code using the above generated C# class to load and process the above presented XML SmallCompanyAAA.xml.

public static void ProcessVer4_Process1(
    string? filePath,
    Microsoft.Extensions.Logging.ILogger? logger)
{
    try
    {
        logger?.LogInformation(
            "+++ProcessVer4_Process1-Start++++++++++++++++++");
        logger?.LogInformation("filePath:" + filePath);

        LxSerializer<XsdExample_Ver4.XSD1.Tns.SmallCompanyElm> serializer = 
            new LxSerializer<XsdExample_Ver4.XSD1.Tns.SmallCompanyElm>();
        TextReader textReader = File.OpenText(filePath ?? String.Empty);
        LxReaderSettings readerSettings = new LxReaderSettings();

        XsdExample_Ver4.XSD1.Tns.SmallCompanyElm? xmlObject =
            serializer.Deserialize(textReader, readerSettings);

        if (xmlObject != null)
        {
            logger?.LogInformation("CompanyName:" + xmlObject.CompanyName);

            foreach(XsdExample_Ver4.XSD1.Tns.SmallCompanyElm.EmployeeElm item in xmlObject.Employees)
            {
                logger?.LogInformation("------------" );
                logger?.LogInformation("Name_String_NO:" + item.Name_String_NO);
                logger?.LogInformation("City_String_O:" + (item.City_String_O ?? "null") );
            }

            foreach (XsdExample_Ver4.XSD1.Tns.SmallCompanyElm.InfoDataElm item in xmlObject.InfoData)
            {
                logger?.LogInformation("------------");
                logger?.LogInformation("Id_Int_NO:" + item.Id_Int_NO.ToString());

                logger?.LogInformation("Quantity_Int_O:" + (item.Quantity_Int_O?.ToString() ?? "null"));
            }
        }
        else
        {
            logger?.LogError("xmlObject == null");
        }

        logger?.LogInformation(
            "+++ProcessVer4_Process1-End++++++++++++++++++");
    }
    catch (Exception ex)
    {
        string methodName =
            $"Type: {System.Reflection.MethodBase.GetCurrentMethod()?.DeclaringType?.FullName}, " +
            $"Method: ProcessVer4_Process1; ";
        logger?.LogError(ex, methodName);
    }
}

And here is the log of execution.

 +++ProcessVer4_Process1-Start++++++++++++++++++
 filePath:C:\TmpXSD\XsdExample_Ver4\Example01\bin\Debug\net8.0\XmlFiles\SmallCompanyAAA.xml
 CompanyName:SmallCompanyAAA
 ------------
 Name_String_NO:Mark
 City_String_O:Belgrade
 ------------
 Name_String_NO:John
 City_String_O:null
 ------------
 Id_Int_NO:11
 Quantity_Int_O:123
 ------------
 Id_Int_NO:22
 Quantity_Int_O:null
 +++ProcessVer4_Process1-End++++++++++++++++++

8 Analysis

This tool uses “nullable_type_style” approach/style to mark Optional Xml-Element presence in generated C# code.

Quantity_Int_O– is int? type and the meaning is a) null - means it was not present b) int – present and had value

9 Conclusion

The full example code project can be downloaded at GitHub [99].

10 References

[1] XML Schema

https://www.w3schools.com/xml/xml_schema.asp

[2] The Difference Between Optional and Not Required

https://www.infopathdev.com/blogs/greg/archive/2004/09/16/The-Difference-Between-Optional-and-Not-Required.aspx

[3] nillable and minOccurs XSD element attributes

https://stackoverflow.com/questions/1903062/nillable-and-minoccurs-xsd-element-attributes

[99] https://github.com/MarkPelf/XsdToolsInNet8

XSD Tools in .NET8 – Part8 – LinqToXsdCore - Advanced

Mark Pelf — Fri, 08 Nov 2024 12:57:12 +0000

A practical guide to XSD tools available in .NET8 environment.

1 Doing XML and XSD related work in .NET8

1.1 List of tools used/tested

Here are the tools used/tested:

Visual Studio 2022
XSD.EXE (Microsoft license, part of VS2022)
XmlSchemaClassGenerator (Open Source/Freeware)
LinqToXsdCore (Open Source/Freeware)
Liquid XML Objects (Commercial license)

1.2 Articles in this series

For technical reasons, I will organize this text into several articles:

XSD Tools in .NET8 – Part1 – VS2022
XSD Tools in .NET8 – Part2 – C# validation
XSD Tools in .NET8 – Part3 – XsdExe – Simple
XSD Tools in .NET8 – Part4 – XsdExe - Advanced
XSD Tools in .NET8 – Part5 – XmlSchemaClassGenerator – Simple
XSD Tools in .NET8 – Part6 – XmlSchemaClassGenerator – Advanced
XSD Tools in .NET8 – Part7 – LinqToXsdCore – Simple
XSD Tools in .NET8 – Part8 – LinqToXsdCore – Advanced
XSD Tools in .NET8 – Part9 – LiquidXMLObjects – Simple
XSD Tools in .NET8 – Part10 – LiquidXMLObjects – Advanced

2 More theory about XML and XSD rules

Here is some more theory about XML and XSD rules.

2.1 Optional Xml-Element and Xml-Attribute

Optional: Does not need to be present in the XML.

For XSD Schema elements:

Optional: minOccurs="0" attribute ->In order to set a schema element as optional, you include the minOccurs="0" attribute

2.2 The Difference Between Optional and Not Required for Xml-Element and Xml-Attribute

Note the difference:

Optional: Does not need to be present in the XML.
Not Required: Does not need to have a value.

You can have any combination:

Optional + Not Required
Optional + Required
Not Optional + Not Required
Not Optional + Required

For XSD Schema elements:

Optional: minOccurs="0" attribute ->In order to set a schema element as optional, you include the minOccurs="0" attribute
Required: nillable="true" attribute ->In order to set a schema element as not required, you include the nillable="true" attribute.

3 Examples of XML and XSD

Here are some sample XML-s and XSD-s I created for test purposes.

3.1 Advanced case

Please note that this example XML/XSD has an Optional and Not-Required Xml-Element. Read the comments inside for more details.

<?xml version="1.0" encoding="utf-8"?>
<!--SmallCompany.xsd++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++-->
<xs:schema attributeFormDefault="unqualified" 
           elementFormDefault="qualified" 
           targetNamespace="https://markpelf.com/SmallCompany.xsd" 
           xmlns:xs="http://www.w3.org/2001/XMLSchema">
    <xs:element name="SmallCompany">
        <xs:complexType>
            <xs:sequence>
                <xs:element name="CompanyName" type="xs:string" />
                <xs:element maxOccurs="unbounded" name="Employee">
                    <xs:complexType>
                        <xs:sequence>
                            <!--Name_String_NO is String NotOptional-->
                            <xs:element name="Name_String_NO" type="xs:string" />
                            <!--City_String_O is String Optional-->
                            <xs:element minOccurs="0" name="City_String_O" type="xs:string" />
                        </xs:sequence>
                    </xs:complexType>
                </xs:element>
                <xs:element maxOccurs="unbounded" name="InfoData">
                    <xs:complexType>
                        <xs:sequence>
                            <!--Id_Int_NO is Int NotOptional-->
                            <xs:element name="Id_Int_NO" type="xs:int" />
                            <!--Quantity_Int_O is Int Optional-->
                            <xs:element minOccurs="0" name="Quantity_Int_O" type="xs:int" />
                        </xs:sequence>
                    </xs:complexType>
                </xs:element>
            </xs:sequence>
        </xs:complexType>
    </xs:element>
</xs:schema>

<?xml version="1.0" encoding="utf-8"?>
<!--SmallCompanyAAA.xml+++++++++++++++++++++++++++++++++++++++++++++++-->
<SmallCompany xmlns="https://markpelf.com/SmallCompany.xsd">
    <CompanyName>SmallCompanyAAA</CompanyName>
    <Employee>
        <Name_String_NO>Mark</Name_String_NO>
        <City_String_O>Belgrade</City_String_O>
    </Employee>
    <Employee>
        <Name_String_NO>John</Name_String_NO>
    </Employee>
    <InfoData>
        <Id_Int_NO>11</Id_Int_NO>
        <Quantity_Int_O>123</Quantity_Int_O>
    </InfoData>
    <InfoData>
        <Id_Int_NO>22</Id_Int_NO>
    </InfoData>
</SmallCompany>

Using LinqToXsdCore tool to create C# class

We focus in this article on the usage of LinqToXsdCore tool to generate C# class from XSD file.

Here is the tool's basic info.


Tool name:  ============================
Liquid XML Objects

License============================ 
2 licenses:
1) Free Community Edition: Home Users and Students, XML Schema (size limited)
2) Commercial Product, Developer Bundle (Installed) $770.94 (perpetual license)

Where to get it============================
https://www.liquid-technologies.com/xml-objects

Install Instructions====================================
-a free trial which will expire 15 days after activation, after this time the product will continue to operate as the Free Community Edition.

Version============================
Liquid Studio - Community Edition 20.7.14.13112

Help============================
https://www.liquid-technologies.com/Reference/XmlDataBinding/xml-objects-introduction.html
====================================================    
Usage Examples===================                         
Instructions to generate C# class 
Using GUI - context right click on .xsd file
====================================

5 Generated C# class

Here is the C# generated by the above tool based on the above presented XSD BigCompany.xsd.

The class's full code produced by this tool is big (835 lines), so I will here show just the beginning of the file.

///////////////////////////////////////////////////////////////////////////
//           Liquid XML Objects GENERATED CODE - DO NOT MODIFY           //
//            https://www.liquid-technologies.com/xml-objects            //
//=======================================================================//
// Dependencies                                                          //
//     Nuget : LiquidTechnologies.XmlObjects.Runtime                     //
//           : MUST BE VERSION 20.7.14                                   //
//=======================================================================//
// Online Help                                                           //
//     https://www.liquid-technologies.com/xml-objects-quick-start-guide //
//=======================================================================//
// Licensing Information                                                 //
//     https://www.liquid-technologies.com/eula                          //
///////////////////////////////////////////////////////////////////////////
using System;
using System.ComponentModel;
using System.Collections.Generic;
using System.Linq;
using System.Xml.Linq;
using System.Numerics;
using LiquidTechnologies.XmlObjects;
using LiquidTechnologies.XmlObjects.Attribution;

// ------------------------------------------------------
// |                      Settings                      |
// ------------------------------------------------------
// GenerateCommonBaseClass                  = False
// GenerateUnprocessedNodeHandlers          = False
// RaiseChangeEvents                        = False
// CollectionNaming                         = Pluralize
// Language                                 = CS
// OutputNamespace                          = XsdExample_Ver4.XSD1
// WriteDefaultValuesForOptionalAttributes  = True
// WriteDefaultValuesForOptionalElements    = True
// MixedContentHandling                     = TreatAsAny
// GenerationModel                          = Simple
//                                            *WARNING* this simplified model that is very easy to work with
//                                            but may cause the XML to be produced without regard for element
//                                            cardinality or order. Where very high compliance with the XML Schema
//                                            standard is required use GenerationModelType.Conformant
// XSD Schema Files
//    C:\TmpXSD\XsdExample_Ver4\Example01\XSD1\SmallCompany.xsd


namespace XsdExample_Ver4.XSD1
{
    #region Global Settings
    /// <summary>Contains library level properties, and ensures the version of the runtime used matches the version used to generate it.</summary>
    [LxRuntimeRequirements("20.7.14.13112", "Free Community Edition", "M9WDQLWDQNEEVNLX", LiquidTechnologies.XmlObjects.LicenseTermsType.CommunityEdition)]
    public partial class LxRuntimeRequirementsWritten
    {
    }

    #endregion

}

namespace XsdExample_Ver4.XSD1.Xs
{
    #region Complex Types
    /// <summary>A class representing the root XSD complexType anyType@http://www.w3.org/2001/XMLSchema</summary>
    [LxSimpleComplexTypeDefinition("anyType", "http://www.w3.org/2001/XMLSchema")]
    public partial class AnyTypeCt : XElement
    {
        /// <summary>Constructor : create a <see cref="AnyTypeCt" /> element &lt;anyType xmlns='http://www.w3.org/2001/XMLSchema'&gt;</summary>
        public AnyTypeCt()  : base(XName.Get("anyType", "http://www.w3.org/2001/XMLSchema")) { }

    }

    #endregion

}

namespace XsdExample_Ver4.XSD1.Tns
{
    #region Elements
    /// <summary>A class representing the root XSD element SmallCompany@https://markpelf.com/SmallCompany.xsd</summary>
    [LxSimpleElementDefinition("SmallCompany", "https://markpelf.com/SmallCompany.xsd", ElementScopeType.GlobalElement)]
    public partial class SmallCompanyElm
    {
        /// <summary>A <see cref="System.String" />, Required : should not be set to null</summary>
        [LxElementValue(0, "CompanyName", "https://markpelf.com/SmallCompany.xsd", LxValueType.Value, XsdType.XsdString, MinOccurs = 1, MaxOccurs = 1)]
        public System.String CompanyName { get; set; } = "";

        /// <summary>A collection of <see cref="XsdExample_Ver4.XSD1.Tns.SmallCompanyElm.EmployeeElm" /></summary>
        [LxElementRef(1, MinOccurs = 0, MaxOccurs = LxConstants.Unbounded)]
        public List<XsdExample_Ver4.XSD1.Tns.SmallCompanyElm.EmployeeElm> Employees { get; } = new List<XsdExample_Ver4.XSD1.Tns.SmallCompanyElm.EmployeeElm>();

        /// <summary>A collection of <see cref="XsdExample_Ver4.XSD1.Tns.SmallCompanyElm.InfoDataElm" /></summary>
        [LxElementRef(2, MinOccurs = 0, MaxOccurs = LxConstants.Unbounded)]
        public List<XsdExample_Ver4.XSD1.Tns.SmallCompanyElm.InfoDataElm> InfoData { get; } = new List<XsdExample_Ver4.XSD1.Tns.SmallCompanyElm.InfoDataElm>();

        /// <summary>Represent the inline xs:element Employee@https://markpelf.com/SmallCompany.xsd.</summary>
        [LxSimpleElementDefinition("Employee", "https://markpelf.com/SmallCompany.xsd", ElementScopeType.InlineElement)]
        public partial class EmployeeElm
        {
            /// <summary>A <see cref="System.String" />, Required : should not be set to null</summary>
            [LxElementValue(0, "Name_String_NO", "https://markpelf.com/SmallCompany.xsd", LxValueType.Value, XsdType.XsdString, MinOccurs = 1, MaxOccurs = 1)]
            public System.String Name_String_NO { get; set; } = "";

            /// <summary>A <see cref="System.String" />, Optional : null when not set</summary>
            [LxElementValue(1, "City_String_O", "https://markpelf.com/SmallCompany.xsd", LxValueType.Value, XsdType.XsdString, MinOccurs = 0, MaxOccurs = 1)]
            public System.String? City_String_O { get; set; }

        }

        /// <summary>Represent the inline xs:element InfoData@https://markpelf.com/SmallCompany.xsd.</summary>
        [LxSimpleElementDefinition("InfoData", "https://markpelf.com/SmallCompany.xsd", ElementScopeType.InlineElement)]
        public partial class InfoDataElm
        {
            /// <summary>A <see cref="System.Int32" />, Required</summary>
            [LxElementValue(0, "Id_Int_NO", "https://markpelf.com/SmallCompany.xsd", LxValueType.Value, XsdType.XsdInt, MinOccurs = 1, MaxOccurs = 1)]
            public System.Int32 Id_Int_NO { get; set; }

            /// <summary>A nullable <see cref="System.Int32" />, Optional : null when not set</summary>
            [LxElementValue(1, "Quantity_Int_O", "https://markpelf.com/SmallCompany.xsd", LxValueType.Value, XsdType.XsdInt, MinOccurs = 0, MaxOccurs = 1)]
            public System.Int32? Quantity_Int_O { get; set; }

        }

    }

    #endregion

}

Here is the class diagram.

The generated class requires very specific dependencies installed in support.

6 Two C# API styles for Optional Xml-Elements

There are two approaches/styles for marking Optional Xml-Element presence in generated C# code:

The first is bool_flag_style – using a bool flag to indicate the presence of optional Xml-Element, with flag=false to indicate the Xml-Element was not present. For example, for some Xml-Element ElemA that, if present, will have value integer, you will get in C# generated two variables “bool ElemA_flag, int ElemA_value”. You need to check if element ElemA was present by first checking the flag ElemA_flag; and then if it is true, you go for the value of ElemA_value. If you do not check flag ElemA_flag first, and just go for the value of ElemA_value you might pick the default int value of zero (0), and you can not know if that is just the default value for C# variable that is always present, but Xml-Element was not present, or that element was present and it actually had the value of zero (0).
The second is nullable_type_style – using a nullable type to indicate the presence of Xml-Element, with value=null to indicate the Xml-Element was not present. For example, for some Xml-Element ElemA that, if present, will have value integer, you will get in C# generated variable “int? ElemA_nullableValue”. You need to check if element ElemA was present by first checking the ElemA_nullableValue not being null; and then if it is not meaning the element was present, you go for the int value of ElemA_nullableValue.

7 Sample C# app

Here is a sample C# code using the above generated C# class to load and process the above presented XML BigCompanyMMM.xml.

public static void ProcessVer4_Process1(
    string? filePath,
    Microsoft.Extensions.Logging.ILogger? logger)
{
    try
    {
        logger?.LogInformation(
            "+++ProcessVer4_Process1-Start++++++++++++++++++");
        logger?.LogInformation("filePath:" + filePath);

        LxSerializer<XsdExample_Ver4.XSD1.Tns.SmallCompanyElm> serializer = 
            new LxSerializer<XsdExample_Ver4.XSD1.Tns.SmallCompanyElm>();
        TextReader textReader = File.OpenText(filePath ?? String.Empty);
        LxReaderSettings readerSettings = new LxReaderSettings();

        XsdExample_Ver4.XSD1.Tns.SmallCompanyElm? xmlObject =
            serializer.Deserialize(textReader, readerSettings);

        if (xmlObject != null)
        {
            logger?.LogInformation("CompanyName:" + xmlObject.CompanyName);

            foreach(XsdExample_Ver4.XSD1.Tns.SmallCompanyElm.EmployeeElm item in xmlObject.Employees)
            {
                logger?.LogInformation("------------" );
                logger?.LogInformation("Name_String_NO:" + item.Name_String_NO);
                logger?.LogInformation("City_String_O:" + (item.City_String_O ?? "null") );
            }

            foreach (XsdExample_Ver4.XSD1.Tns.SmallCompanyElm.InfoDataElm item in xmlObject.InfoData)
            {
                logger?.LogInformation("------------");
                logger?.LogInformation("Id_Int_NO:" + item.Id_Int_NO.ToString());

                logger?.LogInformation("Quantity_Int_O:" + (item.Quantity_Int_O?.ToString() ?? "null"));
            }
        }
        else
        {
            logger?.LogError("xmlObject == null");
        }

        logger?.LogInformation(
            "+++ProcessVer4_Process1-End++++++++++++++++++");
    }
    catch (Exception ex)
    {
        string methodName =
            $"Type: {System.Reflection.MethodBase.GetCurrentMethod()?.DeclaringType?.FullName}, " +
            $"Method: ProcessVer4_Process1; ";
        logger?.LogError(ex, methodName);
    }
}

And here is the log of execution.

 +++ProcessVer4_Process1-Start++++++++++++++++++
 filePath:C:\TmpXSD\XsdExample_Ver4\Example01\bin\Debug\net8.0\XmlFiles\SmallCompanyAAA.xml
 CompanyName:SmallCompanyAAA
 ------------
 Name_String_NO:Mark
 City_String_O:Belgrade
 ------------
 Name_String_NO:John
 City_String_O:null
 ------------
 Id_Int_NO:11
 Quantity_Int_O:123
 ------------
 Id_Int_NO:22
 Quantity_Int_O:null
 +++ProcessVer4_Process1-End++++++++++++++++++

8 Analysis

This tool uses “nullable_type_style” approach/style to mark Optional Xml-Element presence in generated C# code. It does not try to indicate a special case of “nill”.

Data1_Int_NO_R - is int type and always has value
Data2_Int_NO_NR - is int? type and the meaning is: a) null – present but “nill” (we have null here even if the element was present but the value was “nill”) b) int – present and had value
Data3_Int_O_R – is int? type and the meaning is a) null - means it was not present b) int – present and had value
Data4_Int_O_NR - is int? type and the meaning is a) null – means it either was not present or present but “nill”. We can not know which of these 2 cases happened. Strictly speaking, that is a deficiency of this approach/code generated. In some cases, such a distinction might be needed. b) int – present and had value

It is interesting to look at this tool regarding the ability in the case of Xml-Element Data4_Int_O_NR to indicate all three states: “not-present”, “present-nill”, “present-int”. I do not see that using the modern API style/approach “nullable_type_style” the that can be achieved. If Data4_Int_O_NR is null, we can not know if it was “not-present” or “present-nill”.

9 Conclusion

This tool LinqToXsdCore is very interesting and available as freeware. Code C# class generated was very big (it includes some extra methods like Load, Save, Clone), but worked solid in my test. The issue is only that “nillable” option is not handled well at all. Theoretically, that is a problem and for some users, it can be important, if they want a tool that follows all XML specifications.

It can be of interest to users who want to use nullable_type_style API, which is generally a more modern approach to handling the Optional Xml-Elements.

Some things make me a bit reserved about using this tool, like why the generated class is so big. Even more than that is the question of those very specific dependencies libraries, are they maintained, and reliable, and will they cause any conflicts with other XML libraries? Answers to these questions would require more studying of this tool before deciding whether to use it in production.

The full example code project can be downloaded at GitHub [99].

10 References

[1] XML Schema

https://www.w3schools.com/xml/xml_schema.asp

[2] The Difference Between Optional and Not Required

https://www.infopathdev.com/blogs/greg/archive/2004/09/16/The-Difference-Between-Optional-and-Not-Required.aspx

[3] nillable and minOccurs XSD element attributes

https://stackoverflow.com/questions/1903062/nillable-and-minoccurs-xsd-element-attributes

[99] https://github.com/MarkPelf/XsdToolsInNet8