C#新手求助：如何让随机数每次输出不同及编程优化建议

Hey there! Great job tackling a multi-feature project as your first C# endeavor—building a random number generator, calculator, and dice roller is such a solid way to learn core concepts. Let’s break down your questions one by one.

This is a super common gotcha for new C# devs, so don’t feel bad about hitting it! The issue happens because every time you create a new Random instance, it uses the current system clock as a seed. If you’re creating a new Random object in quick succession (like inside a loop or a method you call repeatedly), the clock hasn’t changed enough to generate a unique seed—so you get the same sequence of numbers every time.

The fix is simple: declare your Random instance as a static class-level variable instead of creating a new one each time you roll the dice. Here’s how that looks:

// ❌ Bad: New Random instance every call = duplicate numbers
public int RollDice()
{
    Random random = new Random();
    return random.Next(1, 7); // 1 to 6 for a standard dice
}

// ✅ Good: Static instance initialized once, uses unique seed
private static Random _diceRandom = new Random();

public int RollDice()
{
    return _diceRandom.Next(1, 7);
}

The static _diceRandom variable is initialized once when your class loads, using a seed based on the system’s tick count. Every call to Next() will then pull the next unique number from its sequence. For beginner projects (single-threaded), this will solve your duplicate number problem perfectly.

You’re already doing great by focusing on exception handling and comments—those are habits that’ll serve you well long-term. Here are a few more foundational tweaks to level up your code:

• Stick to C# Naming Conventions
  Follow standard practices to make your code readable for others (and future you!):

  • Classes/methods use PascalCase: DiceRoller, CalculateSum
  • Private fields use camelCase with an underscore prefix: _diceRandom, _calculatorHistory
  • Local variables use camelCase: rollResult, userInput

• Separate Concerns with Classes
  Instead of cramming all three features into one file or class, split them into dedicated classes (e.g., RandomNumberGenerator, BasicCalculator, DiceRoller). Each class should handle one job—this makes your code easier to debug, test, and expand later. For example:

  public class DiceRoller
  {
      private static Random _random = new Random();
      private const int StandardSides = 6;
  
      public int Roll() => Roll(StandardSides);
  
      public int Roll(int numberOfSides)
      {
          if (numberOfSides < 2)
              throw new ArgumentOutOfRangeException(nameof(numberOfSides), "Dice must have at least 2 sides!");
          
          return _random.Next(1, numberOfSides + 1);
      }
  }
  

• Add Meaningful Exception Handling
  You’re already prioritizing exceptions—now make them specific. Instead of catching a generic Exception, catch and throw targeted exceptions like DivideByZeroException for your calculator, or ArgumentOutOfRangeException for invalid dice side counts. Also, include clear error messages so anyone reading the code (or debugging) knows exactly what went wrong.

• Avoid "Magic Numbers"
  Replace hardcoded values (like the 7 in Next(1,7)) with named constants. For example, private const int StandardDiceMax = 6; makes it obvious what the number represents, and if you ever want to change to a 20-sided dice later, you only update one value.

• Try Basic Unit Testing
  Even simple tests can help you catch bugs early. For example, write a test to verify your dice roll always returns a value between 1 and 6, or that your calculator correctly handles addition/subtraction. Most C# IDEs (like Visual Studio) have built-in tools for this, or you can use libraries like xUnit or NUnit. A quick example:

  [Fact]
  public void DiceRoller_ReturnsValueBetween1And6()
  {
      var roller = new DiceRoller();
      int result = roller.Roll();
      Assert.InRange(result, 1, 6);
  }
  

Keep up the great work—building hands-on projects like this is the absolute best way to learn. Don’t hesitate to experiment and refactor as you go—that’s how you’ll grow into a confident developer!

内容的提问来源于stack exchange，提问作者Mr. Spaghett