Передача статических параметров в класс

Question

Насколько я знаю, вы не можете передавать параметры статическому конструктору в C #. Однако у меня есть 2 параметра, которые мне нужно передать и назначить их статическим полям перед созданием экземпляра класса. Как мне это сделать?

Answer 1

Это может быть вызов ... фабричного метода!

class Foo 
{ 
  private int bar; 
  private static Foo _foo;

  private Foo() {}

  static Foo Create(int initialBar) 
  { 
    _foo = new Foo();
    _foo.bar = initialBar; 
    return _foo;
  } 

  private int quux; 
  public void Fn1() {} 
} 

Вы можете поставить галочку, что 'bar' уже инициализирован (или нет) в зависимости от ситуации.

Answer 2

Нельзя передать параметры статическому конструктору, но вы можете передать параметры самому классу - через параметры универсального типа.

Немного сумасшедшая эта идея, однако, я все равно ее просто выкину.

Сделайте класс универсальным (с TypeParam, который предоставит тип параметра) и наложите на него общие ограничения (подробности в примере кода), затем извлеките новый тип параметра, который содержит виртуальные объекты, которые вы можете использовать для чтения того, что они хотят значения параметров должны быть.

//base parameter type - provides the 'anchor' for our generic constraint later, 
//as well as a nice, strong-typed access to our param values.
public class StaticParameterBase
{
  public abstract string ParameterString{ get; }
  public abstract MyComplexType ParameterComplex { get; }
}

//note the use of the new() generic constraint so we know we can confidently create
//an instance of the type.
public class MyType<TParameter> where TParameter:StaticParameterBase, new()
{
  //local copies of parameter values.  Could also simply cache an instance of
  //TParameter and wrap around that. 
  private static string ParameterString { get; set; }
  private static MyComplexType ParameterComplex { get; set; }

  static MyType()
  {
    var myParams = new TParameter();
    ParameterString = myParams.ParameterString;
    ParameterComplex = myParams.ParameterComplex;
  }
}

//e.g, a parameter type could be like this:
public class MyCustomParameterType : StaticParameterBase
{ 
  public override string ParameterString { get { return "Hello crazy world!"; } }
  public override MyComplexType { get {
      //or wherever this object would actually be obtained from.
      return new MyComplexType() { /*initializers etc */ };
    }
  }
}

//you can also now derive from MyType<>, specialising for your desired parameter type
//so you can hide the generic bit in the future (there will be limits to this one's
//usefulness - especially if new constructors are added to MyType<>, as they will 
//have to be mirrored on this type as well).
public class MyType2 : MyType<MyCustomParameterType> { }

//then you'd use the type like this:
public static void main()
{
  var instance = new MyType<MyCustomParameterType>();
  //or this:
  var instance2 = new MyType2();
}

Я действительно рассматривал решение, которое использует настраиваемые атрибуты типа, применимые к параметру типа, однако это легко лучший способ. Тем не менее, теперь вы будете использовать свой класс всегда с универсальным типом параметра (если только вы не можете использовать прием получения + специализации) - возможно, слишком неуклюжий на ваш вкус.

Я бы также предпочел это по сравнению с другими решениями, представленными здесь, так как это не требует создания обходных путей для статической инициализации - вы все еще можете использовать гарантию .Net одноразовой инициализации.

Слово предупреждения - вы должны пересмотреть свою структуру?

Все, что сказано - помните, однако, поскольку вы можете параметризовать статическое значение только один раз (или в этом случае каждый уникально параметризованный статический универсальный тип) - я хотел бы спросить себя, почему бы просто не потянуть код, который получает параметры для выдачи на статический, и поместить его в статический конструктор в первую очередь? Таким образом, вам не придется прибегать к странным моделям, подобным этому!

Answer 3

Полагаю, вы имеете в виду статических членов класса? В этом случае вы можете сделать это:

public class MyClass
{
    public static int MyInt = 12;
    public static MyOtherClass MyOther = new MyOtherClass();    
}

Эти статические члены гарантированно будут созданы перед созданием любого класса.

Если вам нужна сложная логика, сделайте это в статическом конструкторе:

public class MyClass
{
    public static int MyInt;
    public static MyOtherClass MyOther;
    static MyClass()
    {
        MyInt = 12;
        MyOther = new MyOtherClass();
    }
}

Редактировать

Основываясь на ваших изменениях, я бы сказал, просто присвойте значения тем, какими они должны быть, прежде чем создавать экземпляр класса, например:

public class MyClass
{
    public static int MyInt;
    public static MyOtherClass MyOther;
}

// elsewhere in code, before you instantiate MyClass:
MyClass.MyInt = 12;
MyClass.MyOther = new MyOtherClass();
MyClass myClass = new MyClass();

Тем не менее, этот метод не дает никаких гарантий, что MyInt и MyOther установлены до создания экземпляра MyClass. Это будет работать, но требует дисциплины перед созданием экземпляра MyClass.

Один альтернативный шаблон, которому вы можете следовать, выглядит следующим образом:

public class MyClass
{
    private static int MyInt;
    private static MyOtherClass MyOther;
    private static bool IsStaticInitialized = false;

    public static InitializeStatic(int myInt, MyOtherClass other)
    {
        MyInt = myInt;
        MyOther = other;
        IsStaticInitialized = true;
    }

    public MyClass()
    {
        if(!IsStaticInitialized)
        {
            throw new InvalidOperationException("Static Not Initialized");
        }
        // other constructor logic here. 
    }
}

// elsewhere in your code:
MyClass.InitializeStatic(12, new MyOtherClass());
MyClass myClass = new MyClass();

// alternatiavely:
MyClass myClass = new MyClass(); // runtime exception.