C# 从参数池中的随机值中指定特定的初始参数

我正在使用函数初始化构造函数的值。 在构造函数中，我调用这个函数，并根据在构造函数中传递的特定类型初始化参数

public class myclass()
{
    // class parameters of type int\

    public myclass()
    {
        GenerateValues(1);
    }

    private void GenerateValues( int type_of_worker)
    {
        Random rnd = new Random();
        //generate random values for the params
    }

}

有了它，我可以根据传递给构造函数的工人类型生成随机值，这样我就可以有一个基本工人、一个技术人员、一个主管、一个经理等等

但是每个角色都有要求，所以当我创建“manager”类型的worker时，它必须至少有两个大于50（最小0最大99）的参数。如果是控制器，则需要3个等于或大于75的参数

我如何告诉C#为X参数创建随机值，但如果类型为manager，则其中2个必须大于50，或者如果是director，则3个参数ahs必须大于75

例如，如果我创建一个管理器，我会在GenerateValue中使用它：

// main parameters - any value between 1-99 is fine
par1 = rnd.Next(1.99);
par2 = rnd.Next(1.99);
par3 = rnd.Next(1.99);
par4 = rnd.Next(1.99);
par5 = rnd.Next(1.99);
//extra parameters - ANY 2 of these above 50 for manager
par6 = rnd.Next(1.99);
par7 = rnd.Next(50.99);
par8 = rnd.Next(50.99);
par9 = rnd.Next(1.99);

这里的问题是，我不想指定哪个额外参数在50到99之间；但是我希望任何两个额外的参数都必须在50到99之间

---

我可以分配值，然后读取它们，再次更改它们，但这是非常低效的。

我会用更面向对象的方式来做，因为它是C#。见下面的实现

首先，我定义了一个接口来定义合同。从每个工作类型中，我们应该得到整数参数。不确定你的参数是什么样子，我只使用了一个整数数组

然后我添加了一个抽象类来共享一个代码，用于从给定的间隔生成N个随机数

然后我只创建只实现特定逻辑的具体类型

为了简单起见，我使用了LINQ辅助函数。 以下规则用于获取一组随机数：

• 技师-间隔[0,99]中的2个值和[0,50]中的5个值。注意int Next function min参数是包含的，而max参数是独占的
• 控制器-区间[50,99]中的2个值和[0,50]中的5个值
• Manager-区间[75,99]中的3个值和[0,50]中的5个值

  using System.Linq;
  using System.Collections.Generic;
  
  public interface IWorker {
      int[] GetParameters();
  }
  
  abstract class Worker : IWorker {
  
      public abstract int[] GetParameters();
  
      protected IEnumerable<int> GenerateNValues(int quanity, int min, int max) {
          var theRandom = new Random();
          var theResult = new List<int>(quanity);
          for (int i = 0; i < quanity; i++)
              theResult.Add(theRandom.Next(min, max));
          return theResult;
      }
  
      protected IEnumerable<int> Shuffle(IEnumerable<int> array) {
          var theRandom = new Random();
          return array.OrderBy(x => theRandom.Next()).ToArray();  
      }
  }
  
  class Technician : Worker {
      public override int[] GetParameters() {
          return GenerateNValues(2, 0, 100).Concat(GenerateNValues(5, 10, 51)).ToArray();
      }
  }
  
  class Director : Worker {
      public override int[] GetParameters() {
          return GenerateNValues(2, 50, 100).Concat(GenerateNValues(5, 10, 51)).ToArray();
      }
  }
  
  class Manager : Worker {
      public override int[] GetParameters() {
          return Shuffle(GenerateNValues(3, 75, 100).Concat(GenerateNValues(5, 10, 51))).ToArray();
      }
  }
  
  
  public class MyClass
  {
      public MyClass(IWorker aWorker)
      {
          var theParameters = aWorker.GetParameters();
          // do stuff with parameters
      }
  }
  

  使用System.Linq；
  使用System.Collections.Generic；
  公共接口IWorker{
  int[]GetParameters（）；
  }
  抽象类工作者：IWorker{
  公共抽象int[]GetParameters（）；
  受保护的IEnumerable GenerateValue（整数数量、整数最小值、整数最大值）{
  var therrandom=新随机数（）；
  var theResult=新列表（数量）；
  for（int i=0；itheRandom.Next（））.ToArray（）；
  }
  }
  班级技术员：工人{
  公共覆盖int[]GetParameters（）{
  返回GenerateNValues（2,01000）.Concat（GenerateNValues（5,10,51））.ToArray（）；
  }
  }
  班主任：工人{
  公共覆盖int[]GetParameters（）{
  返回GenerateNValues（2,50,100）.Concat（GenerateNValues（5,10,51））.ToArray（）；
  }
  }
  班级经理：工人{
  公共覆盖int[]GetParameters（）{
  返回Shuffle（GenerateNValues（3,75100）.Concat（GenerateNValues（5,10,51））.ToArray（）；
  }
  }
  公共类MyClass
  {
  公共MyClass（IWorker aWorker）
  {
  var theParameters=aWorker.GetParameters（）；
  //使用参数做一些事情
  }
  }
  

---

感谢您的回复；我不想使用接口，因为我一直认为，当您在不同的文件中有不同的类时，它们是有用的，并且您需要它们工作方式的一致性。我掌握的数据大多是int型的，你的假设是正确的。我还没有尝试过这个方法，但是这种方法是否允许我在一个X参数池中为管理器设置2个参数（超过50个）？因为我的大多数问题都与实现这一点的逻辑有关，而我没有指定哪个字段必须大于50。我只是传递了一个列表，X个参数中有2个必须大于50。@newbiez这是一种OOP方式的代码重用，当然你可以只关注

GenerateNValues

函数，使其全局静态，并在应用生成规则时直接使用它。因此，是的，正如我在上面所描述的，这种方法应该允许您为每种工作类型定义特定的逻辑-对于每种情况，您定义将生成的规则：例如2项[50,99]+5项[0,50]。现在唯一的一件事是值按规则分组，如果您想要随机顺序，那么您应该在从

GenerateNValues

返回数组之前对数组进行洗牌。我还添加了

shuffle

函数，并在Manager类中使用它。因此，在生成一组随机数之后，所有的数在返回之前都会被洗牌。