Why Bresenham Algorithm is not fast than DDA Algorithm in C#

Question

I read in stackoverflow before about Bresenham algorithm use for a particular environment like low-language, but I have to compare it in my report so any ideal for my report. How can I prove Bresenham is faster than DDA. Now I created a simple paint on winform C# and the time when I draw with 2 different method is likely equal, sometime DDA is faster. Here is my code in both method

Bresenham Algorithm

        List<Point> vertices = new List<Point>();

        int deltaX = xN - x0; int signX = deltaX >= 0 ? 1 : -1;
        int deltaY = yN - y0; int signY = deltaY >= 0 ? 1 : -1;
        if (deltaX == deltaY && deltaX * deltaY == 0) return vertices;

        // |dy|/|dx| < 1 => |dy| < |dx| => m < 1
        if (Math.Abs(deltaX) > Math.Abs(deltaY))
        {

            int _2deltaX = deltaX * 2 * signX;
            int _2deltaY = deltaY * 2 * signY;
            int p0 = _2deltaY - deltaX * signX;
           
            // create array to contain vertices
            vertices.Add(new Point(x0, y0));

            int xCurrent = x0;
            int yCurrent = y0;
            while (true)
            {
                if (count >= (Math.Abs(deltaX) + 1)) return vertices;

                if (p0 < 0)
                {
                    xCurrent += signX;

                    // pk + 1 = pk + 2.∆y.signX
                    p0 = p0 + _2deltaY;
                }
                else
                {
                    xCurrent += signX;
                    yCurrent += signY;

                    // pk+1= pk + 2.∆y.signX - 2.∆x.signY
                    p0 = p0 + _2deltaY - _2deltaX;
                }
                vertices.Add(new Point(xCurrent, yCurrent));
            }
        }
        // |dy|/|dx| > 1 => |dy| > |dx| => m > 1
        else if (Math.Abs(deltaX) <= Math.Abs(deltaY))
        {

            int _2deltaX = deltaX * 2 * signX;
            int _2deltaY = deltaY * 2 * signY;
            int p0 = _2deltaX - deltaY * signY;

            // create array to contain vertices
            vertices.Add(new Point(x0, y0));

            int xCurrent = x0;
            int yCurrent = y0;
            while (true)
            {
                if (count >= (Math.Abs(deltaY) + 1)) return vertices;

                if (p0 < 0)
                {
                    yCurrent += signY;

                    // pk + 1 = pk + 2.∆x.signY
                    p0 = p0 + _2deltaX;
                }
                else
                {
                    xCurrent += signX;
                    yCurrent += signY;

                    // pk+1= pk + 2.∆x.signY - 2.∆y.signX
                    p0 = p0 + _2deltaX - _2deltaY;
                }
                vertices.Add(new Point(xCurrent, yCurrent));

            }

        }

        return vertices;

DDA Algorithm

        List<Point> vertices = new List<Point>();

        int deltaX = xN - x0; int signX = deltaX >= 0 ? 1 : -1;
        int deltaY = yN - y0; int signY = deltaY >= 0 ? 1 : -1;
        if (deltaX == deltaY && deltaX * deltaY == 0) return vertices;

        
        int step = Math.Abs(deltaX) > Math.Abs(deltaY) ? Math.Abs(deltaX) : Math.Abs(deltaY);

        // x(k + 1) = xk + x'
        double stepX = deltaX * 1.0 / step;
        double stepY = deltaY * 1.0 / step;

        vertices.Add(new Point(x0, y0));

        double xCurrent = x0;
        double yCurrent = y0;


        for (int i = 0; i < step; i++)
        {

            xCurrent += stepX;
            yCurrent += stepY;

            vertices.Add(new Point((int)Math.Round(xCurrent), (int)Math.Round(yCurrent)));
        }
     
        return vertices;