rad | Open source app to read API docs offline | REST library

Perhaps instead of

This is easy:

This is likely because you are setting your x and y values on the cannon and also trying to translate the cannon the same amount. Translate literally moves an entire sheet of canvas with that object drawn on it to the position you want. If you also set an x and y on the object too it will move twice as much. When you translate you are pretty much saying put the (0,0) (top-left) of this sheet of canvas at x and y coordinates of the visible canvas. It's hard to explain since its all one canvas but think of it as each object drawn has it own sheet that can be moved and rotated.

Try this out and see if it is what you are trying to do

I'll give my two cents, without being 100% sure that what I am about to say is correct. Joe Duffy is a world-class expert in multithreading, but I think that in this implementation he has been overly cautious regarding the cross-thread visibility of the internal state of the LockFreeStack class. The volatility of the Node.m_next field is redundant in my opinion. The Node instances are mutable, but they are only mutated before they are linked in the internal linked list. After that phase they are practically immutable. That mutable phase is performed by a single thread, so there is no chance that another thread may see a stale version of a Node instance.

That leaves only the possibility of instructions re-ordering, as a reason for declaring the Node.m_next as volatile. Since the n.m_next = h; assignement is sandwiched between reading another volatile field (m_head), and an Interlocked.CompareExchange operation, I would assume that a possible re-ordering of the instructions that would compromise the correctness of the implementation is already prevented, but as I said I am not 100% sure.

I am pretty sure though that the implementation of the LockFreeStack class could be improved performance-wise, at the cost of becoming slightly more allocatey, by making immutable the Node class. Nowadays (C# 9) this can be achieved simply by switching from type class to type record. This is how such an implementation would look like:

The key here is what bash considers a special builtin to be. I had to dig into the source to find a list:

Can it be because you are calling the background() function inside the loop? (that part is actually not shown in your snippet)

From what you have said in your comment to clarify (completely restate) your problem, you don't need to iterate over all forms.

You are in the context of Form2. As Form2 is "ManualDocked to a Form1 PageControl" then the Parent property of Form2 will be the PageControl (or more likely the TabSheet)

Given the TabSheet it's trival to get to the Form that is hosting it. You could use something like this:

Based on Jimi's comment.

A class

First about the error in your current function GetTimeInMilliSeconds_Windows: Int64;. The error is not a fixed 3 hours as I said. It is 3 hours for me as I live in Finland and our time zone is UTC + 2 hours + 1 hour DST. The error is the same as the diff between UTC time and local time.

The error happens because you call two different functions that convert/return from local time to UTC. Below the function calls and a brief description from MSDN.

GetSystemTime(stt); - Retrieves the current system date and time in Coordinated Universal Time (UTC) format

result: 2021, 5, 2, 25, 15, 23, 39, 219, Time: 15.23.39. My actual local time is 18.23.39

SystemTimeToFileTime(stt, LocalFileTime); - Converts a system time to file time format. System time is based on Coordinated Universal Time (UTC).

LocalFileTimeToFileTime(LocalFileTime, UTCFileTime) - Converts a local file time to a file time based on the Coordinated Universal Time (UTC).

FileTimeToSystemTime(UTCFileTime, UtcSystemTime) - Converts a file time to system time format. System time is based on Coordinated Universal Time (UTC).

result: 2021, 5, 2, 25, 12, 23, 39, 219, Time: 12.23.39

This is my suggestion for a better (in my mind) solution. As you did not say what kind of use cases you have you may have to apply it as needed. Anyway, the result is nr of milliseconds since beginning of 1900.