C# ottiene e imposta le proprietà per una raccolta di liste

Question

Come sono le proprietà per un insieme di raccolta?

Ho creato una classe con proprietà Collection. Voglio aggiungere alla lista ogni volta che imposto un nuovo valore. L'utilizzo di _name.Add (valore) all'interno del metodo set non funziona.

Section newSec = new Section(); 

newSec.subHead.Add("test string"); 
newSec.subHead.Add("another test string"); 

public class Section 
{ 
    public String head { get; set; } 
    private List<string> _subHead = new List<string>(); 
    private List<string> _content = new List<string>(); 

    public List<string> subHead 
    { 
     get 
     { return _subHead; } 
     set 
     { 
      _subHead.Add(value); 
     } 
    } 
    public List<string> content 
    { 
     get 
     { return _content; } 
     set 
     { 
      _content.Add(value); 
     } 
    } 
} 

aggiornamento con la mia soluzione:

public class Section 
{ 

    private List<string> _head = new List<string>(); 
    private List<string> _subHead = new List<string>(); 
    private List<string> _content = new List<string>(); 

    public List<string> Head 
    { 
     get 
     { return _head; } 
    } 

    public List<string> SubHead 
    { 
     get 
     { return _subHead; } 
    } 
    public List<string> Content 
    { 
     get 
     { return _content; } 
    } 

    public void AddHeading(string line) 
    { 
     Head.Add(line); 
    } 

    public void AddSubHeading(string line) 
    { 
     SubHead.Add(line); 
    } 

    public void AddContent(string line) 
    { 
     Content.Add(line); 
    } 

} 

Answer 1

non sarebbe opportuno per essere parte del setter - non è come sei davvero impostando l'intera lista di stringhe - si' Sto solo cercando di aggiungere uno.

Ci sono alcune opzioni:

• Ponga AddSubheading e AddContent metodi nella classe, e solo Exposé sola lettura versioni delle liste
• esporre le liste mutevoli solo con getter, e lasciare che i chiamanti aggiungono a loro
• rinunciare a ogni speranza di incapsulamento, e solo fare loro leggere le proprietà/scrittura

Nel secondo caso, il codice può essere solo:

public class Section 
{ 
    public String Head { get; set; } 
    private readonly List<string> _subHead = new List<string>(); 
    private readonly List<string> _content = new List<string>(); 

    // Note: fix to case to conform with .NET naming conventions 
    public IList<string> SubHead { get { return _subHead; } } 
    public IList<string> Content { get { return _content; } } 
} 

ciò sia ragionevolmente codice pragmatico, anche se non significa che i chiamanti possono mutare le vostre collezioni alcun modo che vogliono, che potrebbe non essere l'ideale. Il primo approccio mantiene il massimo controllo (solo il tuo codice vede mai la lista mutabile) ma potrebbe non essere così conveniente per i chiamanti.

Rendere il setter di un tipo di raccolta in realtà basta aggiungere un singolo elemento a una raccolta esistente non è né fattibile né sarebbe piacevole, quindi ti consiglio di rinunciare a questa idea.

Answer 2

I setter sono strani, motivo per cui potresti riscontrare un problema.

In primo luogo, considerare se ancora bisogno di questi setter - in caso affermativo, dovrebbero prendere un List<string>, non solo un string:

set 
{ 
    _subHead = value; 
} 

queste righe:

newSec.subHead.Add("test string"); 

chiedono il getter e quindi chiamare Add sul reso List<string> - il setter non viene richiamato.

Answer 3

Se ho capito bene la tua richiesta, è necessario effettuare le seguenti operazioni:

public class Section 
{ 
    public String Head 
    { 
     get 
     { 
      return SubHead.LastOrDefault(); 
     } 
     set 
     { 
      SubHead.Add(value); 
     } 

    public List<string> SubHead { get; private set; } 
    public List<string> Content { get; private set; } 
} 

si utilizza in questo modo:

var section = new Section(); 
section.Head = "Test string"; 

Ora "stringa di prova" si aggiunge alla collezione sottotitoli e sarà disponibile attraverso il getter:

var last = section.Head; // last will be "Test string" 

Spero di aver capito bene.

Answer 4

O

public class Section 
{ 
    public String Head { get; set; } 
    private readonly List<string> _subHead = new List<string>(); 
    private readonly List<string> _content = new List<string>(); 

    public IEnumerable<string> SubHead { get { return _subHead; } } 
    public IEnumerable<string> Content { get { return _content; } } 

    public void AddContent(String argValue) 
    { 
    _content.Add(argValue); 
    } 

    public void AddSubHeader(String argValue) 
    { 
    _subHead.Add(argValue); 
    } 
} 

Tutto dipende da quanto del implementaton dei contenuti e sottotitolo che si desidera nascondere.