Why do if-elses, which are said to have no effect when calculating time complexity, create a time difference?

When I test the running speed of the code below, it takes 26 seconds in the worst-case and takes 1 second in the best-case. But ,according to Big-O notation: it's a O(1) and
** O(1)— Constant Complexity**
No matter how large the dataset you have in Constant complexity, the time to run and the resource used are always constant.

static void Main(string[] args)
        {
            Console.WriteLine(DateTime.Now);

            

            for (int i = 0; i < 1000000; i++)
            {
                string x = "aafdsggfjjrffdfhgfhgjfdgfdgfr";
                string y = string.Empty;
                if (x.Contains("rghfjgkhhj"))
                {
                    y = "fdsfdsfds";
                }
                else if (x.Contains("rghfjgkhhj"))
                {
                    y = "fdsfdsfds";
                }
                else if (x.Contains("rghfjgkhhj"))
                {
                    y = "fdsfdsfds";
                }
                else if (x.Contains("rghfjgkhhj"))
                {
                    y = "fdsfdsfds";
                }
				.
				.
				.
				.
				.
				500 times
                else if (x.Contains("rghfjgkhhj"))
                {
                    y = "fdsfdsfds";
                }
            }

            Console.WriteLine(DateTime.Now);
            Console.ReadLine();
        }

So , since it is o(1) there is no time difference then why 26 seconds difference?
(Please don't comment if you don't know how to calculate time complexity.
)

As the comment by the user Some programmer dude, time complexity is just abstract as it sounds - it does not tell you how long in seconds (or any time measurement in that case) the code will finish running, but to give it an abstract evaluation of how good/worst it handles input according to its size.

Not to mention the actual running time is affected by other factors such as:

• Memory allocation speed
• Clock rate of the CPU
  and much more.

The size can be anything you base your methods on: length of an array, length of a string, number of bytes to process etc..

In this case, you measure your O by the number of iterations you're doing in the for loop.

Here everything is a constant:

• The number of iterations of the for-loop.
• Number of if statements.
• The first string's length.
• Other strings also have constant lengths.

So you're correct - your function does not make any use of its input (args), thus does not rely on how scalable it is (for good and bad).

However, it does not mean O(1) runs as fast as O(10000), surely they are in the same complexity group - (O(1)) but they will not finish running at the same time!

Here you're doing 500 million iterations that check if one string is included in the other string, that of-course will be much slower than just doing 1 million iterations, or 100 million iterations, by these according (roughly) factors (~X500, ~X5).
Although they are all in the same "mathematical" set - O(1).