Est-il possible d'initialiser les membres d'une structure sans utiliser de constructeur?

J'ai un struct qui contient deux listes:

struct MonthData
{
   public List<DataRow> Frontline;
   public List<DataRow> Leadership;
}

Cependant, je veux initialiser lorsque la structure est créée. Si j'essaie:

struct MonthData
{
   public List<DataRow> Frontline = new List<DataRow>();
   public List<DataRow> Leadership = new List<DataRow>();
}

Puis-je obtenir:

Error   23  'MonthData.Frontline': cannot have instance field initializers in structs
...

Car les structures ne peut pas avoir sans paramètre constructeurs, je ne peux pas le régler dans un constructeur. Jusqu'à présent, je ne peux que voir les options suivantes:

  1. Initialiser les propriétés lors de la création d'une instance de MonthData
  2. Utiliser une classe au lieu d'une struct
  3. Créer un constructeur avec un paramètre et l'utilisation que
  4. Faire des getters et setters pour les propriétés qui les initialiser
    paresseusement.

Qu'est-ce que l'approche recommandée pour cela? Maintenant, je suis en train de penser, ce qui rend cette classe est la meilleure idée.

source d'informationauteur Mike Christensen | 2011-11-16

  1. 7

    Vous devez utiliser une classe à la place. De MSDN:

    En général, les classes sont utilisées pour modéliser le comportement plus complexe, ou de données qui est destiné à être modifié après une classe de l'objet est créé. Les structures sont les mieux adaptés pour les petites structures de données qui contiennent des données qui n'est pas destiné à être modifié après la structure est créée.

  2. 6

    Vous utilisez les types de référence (List<T>) dans votre structure de toute façon, donc l'utilisation d'une structure comme le type de la valeur n'aurait pas de sens pour moi. Je venais de passer avec une classe.

  3. 6

    Si vous êtes juste de demander à propos de la syntaxe... essayer de construction et à l'aide d'une statique de l'usine à la place... En général, les structures doivent être utilisés pour des choses qui sont immuables, et une usine, (qui appelle un constructeur privé) est une meilleure approche pour un immuable type que l'utilisation d'un constructeur public.

      struct MonthData 
  {    
      public List<DataRow> Frontline;
      public List<DataRow> Leadership; 
      private MonthData(List<DataRow> frontLine = null, 
                        List<DataRow> leadership = null)
      { 
         Frontline = frontLine?? new List<DataRow>();
         Leadership = leadership?? new List<DataRow>();  
      }
      public static MonthData Factory(
          List<DataRow> frontLine= null, 
          List<DataRow> leadership= null)
      { return new MonthData(frontLine, leadership); }
  }
  4. 1

    Il n'y a aucun moyen de le faire avec un constructeur. Le CLR, peut et va créer des instances de structs simplement zéro de l'initialisation de la mémoire et d'éviter tout ctor frais généraux. Cependant, vous pouvez profiter de ces connaissances et de créer de retard initialisé propriétés qui ont le même effet observable.

    Par exemple:

    struct MonthData {  
  private bool m_initialized;
  private List<DataRow> m_frontLine;
  private List<DataRow> m_leaderShip;

  public List<DataRow> FrontLine {
    get {
      EnsureInitialized(); 
      return m_frontLine;
    }
  }

  public List<DataRow> LeaderShip {
    get {
      EnsureInitialized(); 
      return m_leaderShip;
    }
  }

  void EnsureInitialized() {
    if (!m_initialized) {
      m_initialized = true;
      m_frontLine = new List<DataRow>();
      m_leaderShip = new List<DataRow>();
    }
  }
}
  5. 1

    Il aurait été agréable si le CLR a permis à un moyen de garantir que les choses du type de structure qui pourrait avoir un certain code d'initialisation de l'exécuter sur eux avant qu'ils ne deviennent visibles à rien en dehors d'un tel code. Il aurait été possible de le faire, même lors de la création d'un tableau d'un type de structure, en ayant le CLR passer par référence à tous les éléments de la matrice avant une référence à la matrice elle-même a été exposé partout. Malheureusement, il aurait conduit à une situation délicate si une exception a été levée lors de la création de la matrice. Si les constructeurs n'ont pas tous les effets secondaires, il n'y aurait pas de problème-il suffit de jeter le tableau et prétendre que même les objets créés n'a jamais existé. Les constructeurs avec des effets secondaires, cependant, peut causer des difficultés.

    Comme il est, toutefois, il n'y a pas moyen d'initialiser les structures de construction, et par conséquent pas de belle façon à atteindre une valeur de type sémantique avec les objets nécessitant l'initialisation. Désolé. Même si la valeur de type sémantique serait plus approprié pour votre type (comme ce serait le cas beaucoup plus souvent que certains voudraient le croire) que vous aurez à utiliser un type de référence si l'initialisation est nécessaire. Initialisation des structures ne fonctionne pas vraiment. Par exemple, si on a un Dictionnaire<String, MonthData> appelé MyDict, les accès répétés à MyDict("George").Première ligne de chacune de générer une nouvelle Liste. Méchant.

    Mutable structures ne sont pas mal; je suis, si quoi que ce soit, l'un de leurs plus solides défenseurs. Néanmoins, il existe certaines limitations .net de la gestion des mutable structures, il y a donc de nombreuses circonstances où la valeur de type sémantique serait approprié, mais .net restrictions, il est impossible de fournir une telle sémantique correctement.