Other Posts in Randomization

  1. Random String/Password Generation in C#
  2. Lorem Ipsum Generator in C#
  3. Random Generation of Various Types

Lorem Ipsum Generator in C#

2/2/2009

Every time I've created a web page design, I've used Lorem Ipsum as text placeholders. For those of you curious as to what Lorem Ipsum is, it's dummy text. If that's not enough of a description, the link earlier in the post has a better explanation... Anyway, in order to use it I've generally gone online, found a generator, and used that to generate paragraphs of various lengths. To be honest, it's just too annoying (I hate to copy and paste unless I have to). To mitigate this, I created my own:

   1: /*
   2: Copyright (c) 2010 <a href="http://www.gutgames.com">James Craig</a>
   3: 
   4: Permission is hereby granted, free of charge, to any person obtaining a copy
   5: of this software and associated documentation files (the "Software"), to deal
   6: in the Software without restriction, including without limitation the rights
   7: to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
   8: copies of the Software, and to permit persons to whom the Software is
   9: furnished to do so, subject to the following conditions:
  10: 
  11: The above copyright notice and this permission notice shall be included in
  12: all copies or substantial portions of the Software.
  13: 
  14: THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  15: IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  16: FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
  17: AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  18: LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  19: OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
  20: THE SOFTWARE.*/
  21:  
  22: #region Usings
  23: using System;
  24: using System.Drawing;
  25: using System.Text;
  26: using System.Text.RegularExpressions;
  27: using Utilities.DataTypes;
  28: #endregion
  29:  
  30: namespace Utilities.Random
  31: {
  32:     /// <summary>
  33:     /// Utility class for handling random
  34:     /// information.
  35:     /// </summary>
  36:     public class Random : System.Random
  37:     {
  38:         #region Constructors
  39:  
  40:         /// <summary>
  41:         /// Constructor
  42:         /// </summary>
  43:         public Random()
  44:             : base()
  45:         {
  46:         }
  47:  
  48:         /// <summary>
  49:         /// Constructor
  50:         /// </summary>
  51:         /// <param name="Seed">Seed value</param>
  52:         public Random(int Seed)
  53:             : base(Seed)
  54:         {
  55:         }
  56:  
  57:         #endregion
  58:  
  59:         #region Public Functions
  60:  
  61:         /// <summary>
  62:         /// returns a random date/time for a specific date range.
  63:         /// </summary>
  64:         /// <param name="Start">Start time</param>
  65:         /// <param name="End">End time</param>
  66:         /// <returns>A random date/time between the start and end times</returns>
  67:         public DateTime NextDate(DateTime Start, DateTime End)
  68:         {
  69:             if (Start > End)
  70:             {
  71:                 throw new ArgumentException("The start value must be earlier than the end value");
  72:             }
  73:             return Start + new TimeSpan((long)(new TimeSpan(End.Ticks - Start.Ticks).Ticks * NextDouble()));
  74:         }
  75:  
  76:         /// <summary>
  77:         /// returns a randomly generated string
  78:         /// </summary>
  79:         /// <param name="Length">Length of the string</param>
  80:         /// <returns>a randomly generated string of the specified length</returns>
  81:         public string NextString(int Length)
  82:         {
  83:             if (Length < 1)
  84:                 return "";
  85:             return NextString(Length, ".");
  86:         }
  87:  
  88:         /// <summary>
  89:         /// Returns a randomly generated string of a specified length, containing
  90:         /// only a set of characters
  91:         /// </summary>
  92:         /// <param name="Length">length of the string</param>
  93:         /// <param name="AllowedCharacters">Characters that are allowed in the string</param>
  94:         /// <returns>A randomly generated string of the specified length, containing only the allowed characters.</returns>
  95:         public string NextString(int Length, string AllowedCharacters)
  96:         {
  97:             if (Length < 1)
  98:                 return "";
  99:             return NextString(Length, AllowedCharacters, Length);
 100:         }
 101:  
 102:         /// <summary>
 103:         /// Returns a randomly generated string of a specified length, containing
 104:         /// only a set of characters, and at max a specified number of non alpha numeric characters.
 105:         /// </summary>
 106:         /// <param name="Length">Length of the string</param>
 107:         /// <param name="AllowedCharacters">Characters allowed in the string</param>
 108:         /// <param name="NumberOfNonAlphaNumericsAllowed">Number of non alpha numeric characters allowed.</param>
 109:         /// <returns>A randomly generated string of a specified length, containing only a set of characters, and at max a specified number of non alpha numeric characters.</returns>
 110:         public string NextString(int Length, string AllowedCharacters, int NumberOfNonAlphaNumericsAllowed)
 111:         {
 112:             if (Length < 1)
 113:                 return "";
 114:             StringBuilder TempBuilder = new StringBuilder();
 115:             Regex Comparer = new Regex(AllowedCharacters);
 116:             Regex AlphaNumbericComparer = new Regex("[0-9a-zA-z]");
 117:             int Counter = 0;
 118:             while (TempBuilder.Length < Length)
 119:             {
 120:                 string TempValue = new string(Convert.ToChar(Convert.ToInt32(System.Math.Floor(94 * NextDouble() + 32))), 1);
 121:                 if (Comparer.IsMatch(TempValue))
 122:                 {
 123:                     if (!AlphaNumbericComparer.IsMatch(TempValue) && NumberOfNonAlphaNumericsAllowed > Counter)
 124:                     {
 125:                         TempBuilder.Append(TempValue);
 126:                         ++Counter;
 127:                     }
 128:                     else if (AlphaNumbericComparer.IsMatch(TempValue))
 129:                     {
 130:                         TempBuilder.Append(TempValue);
 131:                     }
 132:                 }
 133:             }
 134:             return TempBuilder.ToString();
 135:         }
 136:  
 137:         /// <summary>
 138:         /// Creates a Lorem Ipsum sentence.
 139:         /// </summary>
 140:         /// <param name="NumberOfWords">Number of words for the sentence</param>
 141:         /// <returns>A string containing Lorem Ipsum text</returns>
 142:         public string NextLoremIpsum(int NumberOfWords)
 143:         {
 144:             StringBuilder Builder = new StringBuilder();
 145:             Builder.Append(StringHelper.ToFirstCharacterUpperCase(Words[Next(Words.Length)]));
 146:             for (int x = 1; x < NumberOfWords; ++x)
 147:             {
 148:                 Builder.Append(" ").Append(Words[Next(Words.Length)]);
 149:             }
 150:             Builder.Append(".");
 151:             return Builder.ToString();
 152:         }
 153:  
 154:         /// <summary>
 155:         /// Creates a Lorem Ipsum paragraph.
 156:         /// </summary>
 157:         /// <param name="NumberOfParagraphs">Number of paragraphs</param>
 158:         /// <param name="MaxSentenceLength">Maximum sentence length</param>
 159:         /// <param name="MinSentenceLength">Minimum sentence length</param>
 160:         /// <param name="NumberOfSentences">Number of sentences per paragraph</param>
 161:         /// <param name="HTMLFormatting">Determines if this should use HTML formatting or not</param>
 162:         /// <returns>A string containing Lorem Ipsum text</returns>
 163:         public string NextLoremIpsum(int NumberOfParagraphs, int NumberOfSentences, int MinSentenceLength, int MaxSentenceLength, bool HTMLFormatting)
 164:         {
 165:             StringBuilder Builder = new StringBuilder();
 166:             if (HTMLFormatting)
 167:                 Builder.Append("<p>");
 168:             Builder.Append("Lorem ipsum dolor sit amet. ");
 169:             for (int y = 0; y < NumberOfSentences; ++y)
 170:             {
 171:                 Builder.Append(NextLoremIpsum(Next(MinSentenceLength, MaxSentenceLength))).Append(" ");
 172:             }
 173:             if (HTMLFormatting)
 174:                 Builder.Append("</p>");
 175:             for (int x = 1; x < NumberOfParagraphs; ++x)
 176:             {
 177:                 if (HTMLFormatting)
 178:                     Builder.Append("<p>");
 179:                 for (int y = 0; y < NumberOfSentences; ++y)
 180:                 {
 181:                     Builder.Append(NextLoremIpsum(Next(MinSentenceLength, MaxSentenceLength))).Append(" ");
 182:                 }
 183:                 if (HTMLFormatting)
 184:                     Builder.Append("</p>");
 185:                 else
 186:                     Builder.Append(System.Environment.NewLine).Append(System.Environment.NewLine);
 187:             }
 188:             return Builder.ToString();
 189:         }
 190:  
 191:         /// <summary>
 192:         /// Creates a Lorem Ipsum paragraph.
 193:         /// </summary>
 194:         /// <param name="NumberOfParagraphs">Number of paragraphs</param>
 195:         /// <param name="MaxSentenceLength">Maximum sentence length</param>
 196:         /// <param name="MinSentenceLength">Minimum sentence length</param>
 197:         /// <param name="NumberOfSentences">Number of sentences per paragraph</param>
 198:         /// <returns>A string containing Lorem Ipsum text</returns>
 199:         public string NextLoremIpsum(int NumberOfParagraphs, int NumberOfSentences, int MinSentenceLength, int MaxSentenceLength)
 200:         {
 201:             return NextLoremIpsum(NumberOfParagraphs, NumberOfSentences, MinSentenceLength, MaxSentenceLength, false);
 202:         }
 203:  
 204:         /// <summary>
 205:         /// Returns a random boolean value
 206:         /// </summary>
 207:         /// <returns>returns a boolean</returns>
 208:         public bool NextBool()
 209:         {
 210:             if (Next(0, 2) == 1)
 211:                 return true;
 212:             return false;
 213:         }
 214:  
 215:         /// <summary>
 216:         /// Gets a random enum value
 217:         /// </summary>
 218:         /// <typeparam name="T">The enum type</typeparam>
 219:         /// <returns>A random value from an enum</returns>
 220:         public T NextEnum<T>()
 221:         {
 222:             Array Values = Enum.GetValues(typeof(T));
 223:             int Index = Next(0, Values.Length);
 224:             return (T)Values.GetValue(Index);
 225:         }
 226:  
 227:         /// <summary>
 228:         /// Randomly generates a new time span
 229:         /// </summary>
 230:         /// <param name="Start">Start time span</param>
 231:         /// <param name="End">End time span</param>
 232:         /// <returns>A time span between the start and end</returns>
 233:         public TimeSpan NextTimeSpan(TimeSpan Start, TimeSpan End)
 234:         {
 235:             if (Start > End)
 236:             {
 237:                 throw new ArgumentException("The start value must be earlier than the end value");
 238:             }
 239:             return Start + new TimeSpan((long)(new TimeSpan(End.Ticks - Start.Ticks).Ticks * NextDouble()));
 240:         }
 241:  
 242:         /// <summary>
 243:         /// Returns a random color
 244:         /// </summary>
 245:         /// <returns>A random color between black and white</returns>
 246:         public Color NextColor()
 247:         {
 248:             return NextColor(Color.Black, Color.White);
 249:         }
 250:  
 251:         /// <summary>
 252:         /// Returns a random color within a range
 253:         /// </summary>
 254:         /// <param name="MinColor">The inclusive minimum color (minimum for A, R, G, and B values)</param>
 255:         /// <param name="MaxColor">The inclusive maximum color (max for A, R, G, and B values)</param>
 256:         /// <returns>A random color between the min and max values</returns>
 257:         public Color NextColor(Color MinColor, Color MaxColor)
 258:         {
 259:             return Color.FromArgb(Next(MinColor.A, MaxColor.A + 1),
 260:                 Next(MinColor.R, MaxColor.R + 1),
 261:                 Next(MinColor.G, MaxColor.G + 1),
 262:                 Next(MinColor.B, MaxColor.B + 1));
 263:         }
 264:  
 265:         #endregion
 266:  
 267:         #region Private Variables
 268:  
 269:         private string[] Words = new string[] { "consetetur", "sadipscing", "elitr", "sed", "diam", "nonumy", "eirmod",
 270:         "tempor", "invidunt", "ut", "labore", "et", "dolore", "magna", "aliquyam", "erat", "sed", "diam", "voluptua",
 271:         "at", "vero", "eos", "et", "accusam", "et", "justo", "duo", "dolores", "et", "ea", "rebum", "stet", "clita",
 272:         "kasd", "gubergren", "no", "sea", "takimata", "sanctus", "est", "lorem", "ipsum", "dolor", "sit", "amet",
 273:         "lorem", "ipsum", "dolor", "sit", "amet", "consetetur", "sadipscing", "elitr", "sed", "diam", "nonumy", "eirmod",
 274:         "tempor", "invidunt", "ut", "labore", "et", "dolore", "magna", "aliquyam", "erat", "sed", "diam", "voluptua",
 275:         "at", "vero", "eos", "et", "accusam", "et", "justo", "duo", "dolores", "et", "ea", "rebum", "stet", "clita",
 276:         "kasd", "gubergren", "no", "sea", "takimata", "sanctus", "est", "lorem", "ipsum", "dolor", "sit", "amet",
 277:         "lorem", "ipsum", "dolor", "sit", "amet", "consetetur", "sadipscing", "elitr", "sed", "diam", "nonumy", "eirmod",
 278:         "tempor", "invidunt", "ut", "labore", "et", "dolore", "magna", "aliquyam", "erat", "sed", "diam", "voluptua",
 279:         "at", "vero", "eos", "et", "accusam", "et", "justo", "duo", "dolores", "et", "ea", "rebum", "stet", "clita",
 280:         "kasd", "gubergren", "no", "sea", "takimata", "sanctus", "est", "lorem", "ipsum", "dolor", "sit", "amet", "duis",
 281:         "autem", "vel", "eum", "iriure", "dolor", "in", "hendrerit", "in", "vulputate", "velit", "esse", "molestie",
 282:         "consequat", "vel", "illum", "dolore", "eu", "feugiat", "nulla", "facilisis", "at", "vero", "eros", "et",
 283:         "accumsan", "et", "iusto", "odio", "dignissim", "qui", "blandit", "praesent", "luptatum", "zzril", "delenit",
 284:         "augue", "duis", "dolore", "te", "feugait", "nulla", "facilisi", "lorem", "ipsum", "dolor", "sit", "amet",
 285:         "consectetuer", "adipiscing", "elit", "sed", "diam", "nonummy", "nibh", "euismod", "tincidunt", "ut", "laoreet",
 286:         "dolore", "magna", "aliquam", "erat", "volutpat", "ut", "wisi", "enim", "ad", "minim", "veniam", "quis",
 287:         "nostrud", "exerci", "tation", "ullamcorper", "suscipit", "lobortis", "nisl", "ut", "aliquip", "ex", "ea",
 288:         "commodo", "consequat", "duis", "autem", "vel", "eum", "iriure", "dolor", "in", "hendrerit", "in", "vulputate",
 289:         "velit", "esse", "molestie", "consequat", "vel", "illum", "dolore", "eu", "feugiat", "nulla", "facilisis", "at",
 290:         "vero", "eros", "et", "accumsan", "et", "iusto", "odio", "dignissim", "qui", "blandit", "praesent", "luptatum",
 291:         "zzril", "delenit", "augue", "duis", "dolore", "te", "feugait", "nulla", "facilisi", "nam", "liber", "tempor",
 292:         "cum", "soluta", "nobis", "eleifend", "option", "congue", "nihil", "imperdiet", "doming", "id", "quod", "mazim",
 293:         "placerat", "facer", "possim", "assum", "lorem", "ipsum", "dolor", "sit", "amet", "consectetuer", "adipiscing",
 294:         "elit", "sed", "diam", "nonummy", "nibh", "euismod", "tincidunt", "ut", "laoreet", "dolore", "magna", "aliquam",
 295:         "erat", "volutpat", "ut", "wisi", "enim", "ad", "minim", "veniam", "quis", "nostrud", "exerci", "tation",
 296:         "ullamcorper", "suscipit", "lobortis", "nisl", "ut", "aliquip", "ex", "ea", "commodo", "consequat", "duis",
 297:         "autem", "vel", "eum", "iriure", "dolor", "in", "hendrerit", "in", "vulputate", "velit", "esse", "molestie",
 298:         "consequat", "vel", "illum", "dolore", "eu", "feugiat", "nulla", "facilisis", "at", "vero", "eos", "et", "accusam",
 299:         "et", "justo", "duo", "dolores", "et", "ea", "rebum", "stet", "clita", "kasd", "gubergren", "no", "sea",
 300:         "takimata", "sanctus", "est", "lorem", "ipsum", "dolor", "sit", "amet", "lorem", "ipsum", "dolor", "sit",
 301:         "amet", "consetetur", "sadipscing", "elitr", "sed", "diam", "nonumy", "eirmod", "tempor", "invidunt", "ut",
 302:         "labore", "et", "dolore", "magna", "aliquyam", "erat", "sed", "diam", "voluptua", "at", "vero", "eos", "et",
 303:         "accusam", "et", "justo", "duo", "dolores", "et", "ea", "rebum", "stet", "clita", "kasd", "gubergren", "no",
 304:         "sea", "takimata", "sanctus", "est", "lorem", "ipsum", "dolor", "sit", "amet", "lorem", "ipsum", "dolor", "sit",
 305:         "amet", "consetetur", "sadipscing", "elitr", "at", "accusam", "aliquyam", "diam", "diam", "dolore", "dolores",
 306:         "duo", "eirmod", "eos", "erat", "et", "nonumy", "sed", "tempor", "et", "et", "invidunt", "justo", "labore",
 307:         "stet", "clita", "ea", "et", "gubergren", "kasd", "magna", "no", "rebum", "sanctus", "sea", "sed", "takimata",
 308:         "ut", "vero", "voluptua", "est", "lorem", "ipsum", "dolor", "sit", "amet", "lorem", "ipsum", "dolor", "sit",
 309:         "amet", "consetetur", "sadipscing", "elitr", "sed", "diam", "nonumy", "eirmod", "tempor", "invidunt", "ut",
 310:         "labore", "et", "dolore", "magna", "aliquyam", "erat", "consetetur", "sadipscing", "elitr", "sed", "diam",
 311:         "nonumy", "eirmod", "tempor", "invidunt", "ut", "labore", "et", "dolore", "magna", "aliquyam", "erat", "sed",
 312:         "diam", "voluptua", "at", "vero", "eos", "et", "accusam", "et", "justo", "duo", "dolores", "et", "ea",
 313:         "rebum", "stet", "clita", "kasd", "gubergren", "no", "sea", "takimata", "sanctus", "est", "lorem", "ipsum" };
 314:  
 315:         #endregion
 316:     }
 317: }
   1: /// <summary>
   2: /// Takes the first character of an input string and makes it uppercase
   3: /// </summary>
   4: /// <param name="Input">Input string</param>
   5: /// <returns>String with the first character capitalized</returns>
   6: public static string ToFirstCharacterUpperCase(string Input)
   7: {
   8:     if (string.IsNullOrEmpty(Input))
   9:         return null;
  10:     char[] InputChars = Input.ToCharArray();
  11:     for (int x = 0; x < InputChars.Length; ++x)
  12:     {
  13:         if (InputChars[x] != ' ' && InputChars[x] != '\t')
  14:         {
  15:             InputChars[x] = char.ToUpper(InputChars[x]);
  16:             break;
  17:         }
  18:     }
  19:     return new string(InputChars);
  20: }

The first class is the actual random Lorem Ipsum generator and there are two options. The first simply generates a sentence. The second actually generates a number of paragraphs. It uses, for the most part, proper capitalization but punctuation is hit or miss (let alone the fact that each word is random so if you know Latin, the sentences will definately be nonsensical). Also, the word list I was lucky enough to find here. I would have used his code as well but it didn't offer the flexibility that I wanted (nor the html markup). The second class is simply a string helper function. It takes the first letter in the input string and capitalizes it. That's all the function is there for. Anyway, I hope this helps out someone. So try it out, leave feedback, and happy coding.



Comments

slan
February 27, 2010 3:23 PM

Thank you very much! Pretty helpful utility.