stackframe | JS Object representation of a stack frame | Runtime Evironment library

Before J2SE 5.0, Java did not have covariant return types. The JVM bytecode rules are that it overrides on exact parameter match including the return type. So the compiler inserts a synthetic bridge method that you are seeing.

Perhaps surprisingly, the JLS doesn't talk much about bridge methods. It is in the notes on the section Create Frame, Synchronize, Transfer Control in the Expressions chapter.

Have you already considered using the TransactionScope class?

I'm not sure, but with that, you might not need to know whether you are in a transaction or not inside your ExecuteQuery and GetDataSet methods. It might just simply work. ;)

Your Transaction method could look something like this:

Looking at the error labeled 3, it is saying that it is not your Product that isn't defined, but rather it's something inside your Card.Body that isn't defined.

I don't see a Card.Image in the react-bootstrap docs, but I do see a Card.Img. Try using that.

You can do away with the stack-based security by introducing a context object that provides access to the event.

But first, a few notes. I'm not going to speak to the merits of this design because that's subjective. However, I will address some terminology, naming, and design matters.

1. .NET's naming convention for events does not includethe "On" prefix. Rather, the method that raises the event (marked private or protected virtual, depending on whether you can inherit the class) has the "On" prefix. I've followed this convention in the code below.

2. The name "DelegateFactory" sounds like something that create delegates. This does not. It accepts a delegate and you're using it to perform an action within a retry loop. I'm having a tough time word-smithing this one, though; I've called the class Retryer and the method Execute in the code below. Do with that what you will.

3. DelegateWork/Execute return a bool but you never check it. It's unclear if that's an oversight in the example consumer code or a flaw in this thing's design. I'll leave it to you to decide, but because it follows the Try pattern to determine if the output parameter is valid, I'm leaving it there and using it.

4. Because you're talking about network-related actions, consider writing one or more overloads that accept an awaitable delegate (i.e. returns Task). Because you can't use ref or out parameters with async methods, you'll need to wrap the bool status value and the return value of the delegate in something, such as a custom class or a tuple. I will leave this as an exercise to the reader.

5. If an argument is null, make sure you throw ArgumentNullException and simply pass it the name of the argument (e.g. nameof(work)). Your code throws ArgumentException, which is less specific. Also, use the is keyword to ensure you're doing a reference equality test for null and not accidentally invoking overloaded equality operators. You'll see that in the code below, as well.

Introducing a Context Object

I'm going to use a partial class so that the context is clear in each snippet.

First, you have the events. Let's follow the .NET naming convention here because we want to introduce invoker methods. It's a static class (abstract and sealed) so those will be private. The reason for using invoker methods as a pattern is to make raising an event consistent. When a class can be inherited and an invoker method needs to be overridden, it has to call the base implemention to raise the event because the deriving class doesn't have access to the event's backing storage (that could be a field, as in this case, or perhaps the Events property in a Component-derived type where the key used on that collection is kept private). Although this class is uninheritable, it's nice to have a pattern you can stick to.

The concept of raising the event is going to go through a layer of semantic translation, since the code that registers the event handler may not be the same as the code that calls this method, and they could have different perspectives. The caller of this method wants to post a message. The event handler wants to know that a message has been received. Thus, posting a message (PostMessage) gets translated to notifying that a message has been received (OnMessageReceived).

Don't use modifiable objects as function default arguments.

They are created at function compilation and not at function call. And are reused for every call.

Use None and create the modifiable inside the function.

And make a copy of the modifiable at the recursive call.

It requires to have DTO class with required number of properties and then loop over the Dto to bind the datatable fields with DTO properties.

here is the example code

Thank @Micka for the many advises, I found the right thing on the way.

Using cudacodec::VideoWriter is not that easy, after compiling I was not able to use it because of this error, and even if I can make it run, the deployment PC does not have a nvidia GPU.

Since I am going to use PCs with AMD CPUs as well, I can't use the cv::CAP_INTEL_MFX for the api-reference parameter of the cv::VideoWriter. But there is also the cv::CAP_OPENCV_MJPEG, which works fine for the MJPG codec (not all video container are supported, I use .avi, sadly .mkv was not working with this configuration). If the user does not use MJPG as a codec I use cv::CAP_ANY, and opencv decides what is to use.

So,

Ignore the internal details of String. As far as you are concerned it does not have an encoding, it just stores sequences of characters (or "code point units" as the Kotlin docs describe them).

I'm guessing one of your strings (that was Latin-1) uses the character U+00E4 (ä) and the other uses the sequence U+0061 U+0308 (ä). You can verify using toCharArray().

To be able to compare such strings sensibly, there is the class java.text.Normalizer:

The first variant stores the local variable in the red zone, a 128 byte area below the stack pointer that is not changed by signal handlers. The second variant cannot use the red zone because the callq instruction writes to the (original) red zone, clobbering the local variable stored there. (The called function could write to the original red zone as well, of course.)

%eax is set to zero because the function definition declares no prototype, so the compiler has to assume it is a variadic function. The %eax (actually %al) is used to optimize the implementation of variadic functions.