Terry, it appears that you do not have a well behaved random number
generator. I have attached a C# class that generates well behaved random
numbers. However, if you want a quick and dirty use the following:

BEGIN QUICK AND DIRTY

           ulong       ia = 106 ;
           ulong       ic = 1283 ;
           ulong       im = 6075 ;
           ulong       j = 0 ;
           ulong       jhi = <set to Upper limit> ;
           ulong       jlo = <set to Lower limit> ;
           ulong       jran = ( im - 7 ) ;

           jran = ( jran * ia + ic ) % im ;
           j = jlo + ( ( jhi - jlo + 1 ) * jran ) /im ;

END QUICK AND DIRTY

See section 7.1 and following in

       http://www.library.cornell.edu/nr/bookcpdf.html

for a discussion of both, but especially for the quick and dirty. The
section includes other constants thgat can be used depending upon the machine
overflow.

BEGIN C# class

namespace CNA_Library
   {
   using System ;
   using System.Configuration ;
   using System.Data ;
   using System.Data.SqlClient ;
   using System.Drawing ;
   using System.Text ;
   using System.Web ;
   using System.Web.Mail ;
   using CNA_Library ;

 
    public class Random_Variants
       {

// *********************************** Compilation unit constants

                const      int     IA = ( 16807 ) ;
                const      int     IM = ( 2147483647 ) ;
                const      float   AM = ( 1.0f /
                                          ( float ) IM ) ;
                const      int     IQ = ( 127773 ) ;
                const      int     IR = ( 2836 ) ;
                const      int     NTAB = ( 32 ) ;
                const      int     NDIV = ( 1 + ( IM - 1 ) /
                                                NTAB ) ;
                const      float   EPS = ( ( float ) 1.2e-7 ) ;
                const      float   RNMX = ( 1.0f - EPS ) ;
       
       protected static    long[]  iv = new long [ NTAB ] ;
       protected static    long    iy = 0 ;
         

// ********************************************************* ran1

       /// <remarks>
       /// "Minimal" random number generator of Park and Miller
       /// with Bays and Durham shuffle and added safeguards.  
       /// Returns a random  variate between 0.0 and 1.0, ex-
       /// clusive of the endpoint values.
       ///
       /// Call with initialize set to a negative integer to
       /// initialize; thereafter, do not alter initialize
       /// between successive deviates in a sequence.  
       ///
       /// RNMX should approximate the largest floating point
       /// value that is less than 1.
       ///
       /// From "Numerical Recipes in C: The Art of Scientific
       /// Computing", ISBN 0-521-43108-5, pg 280.  See section
       /// 7.1 in
       ///
       ///     http://www.library.cornell.edu/nr/bookcpdf.html
       /// </remarks>

       private float ran1 ( ref long initialize )
           {
           long    j ;
           long    k = 0 ;
           float   temp ;
           
           if ( ( initialize <= 0 ) || ( iy == 0 ) )
               {
                                      // avoid initialize == 0
               if ( -( initialize ) < 1 )
                   {
                   initialize = 1 ;
                   }
               else
                   {
                   initialize = - ( initialize ) ;
                   }
                                      // load shuffle table
                                      // ( after 8 warmups)
               for ( j = ( NTAB + 7 ); ( j >= 0 ); j-- )
                   {
                   k = ( initialize ) / IQ ;
                   initialize = IA * ( initialize - k * IQ ) -
                                IR * k ;
                   if ( initialize < 0 )
                       {
                       initialize += IM ;
                       }
                   if ( j < NTAB )
                       {
                       iv [ j ] = initialize ;
                       }
                   }
               iy = iv [ 0 ] ;
               }
                                       // starts here when not
                                       // initializing

                                       // compute initialize=
                                       //     (IA*initialize)%IM
                                       // without overflow
                                       // using Schrange's
                                       // method
           k = ( initialize ) / IQ ;
           initialize = IA * ( initialize - k * IQ ) - IR * k ;
           if ( initialize < 0 )
               {
               initialize += IM ;
               }
           j = iy / NDIV ;             // in range 0..NTAB-1
           iy = iv [ j ] ;             // retrieve previous
           iv [ j ] = initialize ;     // refill shuffle table

                                       // do not include end-
                                       // points in the returned
                                       // value
           if ( ( temp = ( float ) ( AM * iy ) ) > RNMX )
               {
               temp = ( float ) RNMX ;
               }
               
           return ( temp ) ;
           }

// ***************************************** long_uniform_variate

       /// <summary>
       /// long long_uniform_variate ( long  initialize,
       ///                             long  minimum,
       ///                             long  maximum )
       /// </summary
       /// <param name='initialize'>
       /// long containing and initializing indicator, should
       /// be -1 and then never changed.
       /// </param>
       /// <param name='minimum'>
       /// long containing the smallest long value to be
       /// returned.
       /// </param>
       /// <param name='maximum'>
       /// long containing the largest long value to be
       /// returned.
       /// </param>
       /// <returns>
       /// long containing a random value in the range minimum
       //  to maximum, exclusive.  This function does not return
       /// the maximum value.  If the value of maximum is de-
       /// sired, add one to the supplied value.  For example,
       /// if the desired range of values is 1 through 4, includ-
       /// ing the value 4, invoke the function as:
       ///
       ///     long_uniform_variate ( 1, 5 )
       /// </returns>

       public long long_uniform_variate ( ref long  initialize,
                                              long  minimum,
                                              long  maximum )
           {

           return ( ( minimum +
                   ( int ) ( ( float ) ( maximum - minimum ) *
                               ran1 ( ref initialize ) ) ) ) ;
           }
   
       } // class
   } // namespace

END C# class

HTH

Gus

Try creating just one global System.Random object. You'll gain both speed
and correctness.
The System.Random number generator is initialized with the timer, creating
two different random number generators in short time will initialize them
both with the same sequence (and you'll get repeating numbers).

--
Marco *PaN!* Foco