aguid | : snowflake : A Globally Unique IDentifier | Identity Management library

I found an explanation.

Since 2019, Microsoft is releasing KBs that changes the default value of the "SameSite" attribute for the cookies. Before, when creating an auth cookie with FormsAuthentication.SetAuthCookie, the SameSite attribute was not specified, and in most browsers, the default value for it was "none" and it worked just fine. (this is not the case with Chrome anymore since february 2020, the default value became "lax").

Now, with the KBs I mentionned, the default value became "Strict", that's why my authentication doesn't work anymore in my case.

So, I'll have to specify the samesite attribute of my auth cookie to "None" manually if possible, and think about the security issues I could have with that. As a last resort, I could also just use the same domain name for my two websites.

You can access attributes and their data by using reflection:
Accessing Attributes by Using Reflection (C#)
Retrieving Information Stored in Attributes

But I would suggest to use FluentAssertions library, which provide same approach in a fluently readable way.

Strangest thing I have ever seen. Change the parameter type from standard "Guid aParam" to "ref Guid aParam" and it works just fine now.

Update: false success. Seems it also depends on when you have rebooted your system. I am still able to generate the problem and, after even further investigation, have concluded that this might be a debugger/ReSharper issue in that I can now create a case using simple code that replicates the same problem. Once need only create a separate solution, add a package with a class that implements an interface, add a different interface from some other simple class, turn the whole thing into a NuGet package, create a second solution, create a simple class that uses in instance of the class in the NuGet package and start single stepping. Fails there, or at least the debugger fails to show the correct value when stepping through the code.

If you want to use that structure, you should use a Dictionary:

You're not really using a service layer pattern. Your "service" is just a repository, which then uses your unit of work to access another repository. In short, you've got multiple layers of meaningless abstraction here, which will absolutely kill you in an app you have to maintain for any amount of time.

In general, you should not use the unit of work / repository patterns with ORMs like Entity Framework. The reason why is simple: these ORMs already implement these patterns. In the case of EF, the DbContext is your unit of work and each DbSet is a repository.

If you're going to use something like Entity Framework, my best advice is to just use it. Reference it in your app, inject your context into your controllers and such, and actually use the EF API to do the things you need to do. Isn't this creating a tight coupling? Yes. Yes it is. However, the point so many miss (even myself for a long time) is that coupling is already there. Even if you abstract everything, you're still dealing with a particular domain that you can never fully abstract. If you change your database, that will bubble up to your application at some point, even if it's DTOs you're changing instead of entities. And, of course you'll still have to change those entities as well. The layers just add more maintenance and entropy to your application, which is actually the antithesis of the "clean code" architecture abstractions are supposed to be about.

But what if you need to switch out EF with something else? Won't you have to rewrite a bunch of code? Well, yeah. However, that pretty much never happens. Making a choice on something like an ORM has enough momentum that you're not likely to be able to reverse that course no matter what you do, regardless of how many layers of abstractions you use. It's simply going to require too much time and effort and will never be a business priority. And, importantly, a bunch of code will have to be rewritten regardless. It's only a matter of what layer it's going to be done in.

Now, all that said, there is value in certain patterns like CQRS (Command Query Responsibility Segregation), which is an abstraction (and not a meaningless one, that). However, that only makes sense in large projects or domains where you need clear cut separation between things like reads and writes and/or event sourcings (which goes naturally with CQRS). It's overkill for the majority of applications.

What I would recommend beyond anything else if you want to abstract EF from your main application is to actually create microservices. These microservices are basically just little APIs (though they don't have to be) that deal with just a single unit of functionality for your application. Your application, then, makes requests or otherwise access the microservices to get the data it needs. The microservice would just use EF directly, while the application would have no dependency on EF at all (the holy grail developers think they want).

With a microservice architecture, you can actually check all the boxes you think this faux abstraction is getting you. Want to switch out EF with something else? No problem. Since each microservice only works with a limited subset of the domain, there's not a ton of code typically. Even using EF directly, it would be relatively trivial to rewrite those portions. Better yet, each microservice is completely independent, so you can switch EF out on one, but continue using EF on another. Everything keeps working and the application couldn't care less. This gives you the ability to handle migrations over time and at a pace that is manageable.

Long and short, don't over-engineer. That's the bane of even developers who've been in the business for a while, but especially of new developers, fresh out of the gates with visions of code patterns dancing in their heads. Remember that the patterns are there as recommended ways to solve specific problems. First, you need to ensure that you actually have the problem, then you need to focus on whether that pattern is actually the best way to solve that problem your specific circumstance. This is a skill - one you'll learn over time. The best way to get there is to start small. Build the bare minimum functionality in the most straight-forward way possible. Then, refactor. Test, profile, throw it to the wolves and drag back the blood-soaked remains. Then, refactor. Eventually, you might end up implementing all kinds of different layers and patterns, but you also might not. It's those "might not" times that matter, because in those cases, you've got simple, effortlessly maintainable code that just works and that didn't waste a ton of development time.

most likely you have the wrong GUID I have the same problem.

I pointed out the GUID of the class and not the interface. I used {e0cbf06c-cd8b-4647-bb8a-263b43f0f974}

But but I need {0850302A-B344-4fda-9BE9-90576B8D46F0}

Try this:)

Close, but you need a from clause:

In case this helps somebody in the future, this is how I solved the issue.

As I know the barcode will always be 28 characters long then I hard coded the creation of $crypt

This is our old friend delayed expansion issue.

There are tons of questions about variable expansion within blocks.

When the command processor finds a block (anything between parentheses), parses it completely and expand variables to the value they have when the block is evaluated. If you update a variable value within a block, you need to enable delayed expansion for the variable to reflect changes made. Also you must change var syntax from %var% to !var!.

In your code, aGUID var is generated within a for block, so it's expanded to the value it holds when the block begins (in your case empty or undefined). To update value every iteration of the for block you need to enable delayed expansion.

Another workaround is to use a new for loop to grab output of uuidgen.exe as for variables are always expanded inline. This approach gives you another benefit, you won't need a temp file.

NOTE: Also, you are writing multiple lines to a file, note that