How often, with what range? Can you tell us more about what you're
doing?

True, but specifying the ticks gives me a stub I can modify later.

Since Next() always scrambles its seed, regardless of calling thread, why is
this of concern?

Jon

You can always look at the Random class in Reflector to see exactly
what it does.  It's plain .NET managed code.

It's more than 3 lines, but not all that much more.  :-)

Sam

------------------------------------------------------------
We're hiring!  B-Line Medical is seeking .NET
Developers for exciting positions in medical product
development in MD/DC.  Work with a variety of technologies
in a relaxed team environment.  See ads on Dice.com.

Typical C RTL rand() has poor randomness in low digits. You always had
to use division rather than modulus to get good results.

It sounds like you may have been using modulus, which would have left
the least significant digits untouched, especially if your modulus was
even and you were grouping resulting numbers by even/odd.

-- Barry

Seemed like an interesting thing to try.  Here you go:
http://www.petrotta.org/random.png
I can't spot any patterns in it, not that I expected to.  It's
interesting to note that compressing to png saved only 18 bytes out of
the 459K bitmap.  That's a sign of random data :-)

Here's the source.  It's a pretty naive (and slow) creation of an
image with random grayscale data.  I'm sure there are better ways to
do this.  I'd like to try creating 16bpp images too.

using System;
using System.Drawing;

namespace RandomGrays
{
    class Program
    {
        static void Main(string[] args)
        {
            if (args.Length != 3)
            {
                throw new ArgumentOutOfRangeException("Usage: randomgrays <width>
<height> <outfile>");
            }

            int width = Convert.ToInt32(args[0]);
            int height = Convert.ToInt32(args[1]);
            string fileName = args[2].ToString();
            Bitmap b = new Bitmap(width, height);
            Random r = new Random();
            for (int x = 0; x < width; x++)
            {
                for (int y = height - 1; y >= 0; y--) // eye scan order == write
order
                {
                    int random = r.Next(255);
                    b.SetPixel(x, y, Color.FromArgb(random, random, random));
                }
            }
            b.Save(fileName);
        }
    }
}

Michael

(apologies if this is a repost.  I don't believe my first attempt went
out)

Seemed like an interesting thing to try.  Here you go:
http://www.petrotta.org/random.png

A 640x480 bitmap of random grayscale pixels.  Looks pretty random to
me, if a little bipolar.  A histogram shows that it's pretty flat
across the values, though.

Here's the source.  I'm sure there are better ways to do this, if only
because this was dead slow:

using System;
using System.Drawing;

namespace RandomGrays
{
    class Program
    {
        static void Main(string[] args)
        {
            if (args.Length != 3)
            {
                throw new ArgumentOutOfRangeException("Usage: randomgrays <width>
<height> <outfile>");
            }

            int width = Convert.ToInt32(args[0]);
            int height = Convert.ToInt32(args[1]);
            string fileName = args[2].ToString();
            Bitmap b = new Bitmap(width, height);
            Random r = new Random();
            for (int x = 0; x < width; x++)
            {
                for (int y = height - 1; y >= 0; y--) // eye scan order == write
order
                {
                    int random = r.Next(255);
                    b.SetPixel(x, y, Color.FromArgb(random, random, random));
                }
            }
            b.Save(fileName);
        }
    }
}

Michael