Tworzenie właściwości dla listy <T>

Question

private List<T> newList; 

public List<T> NewList 
{ 
get{return newList;} 
set{newList = value;} 
} 

Chcę utworzyć coś takiego, ale to nie zadziała. jest to tylko przykład do zademonstrowania mojego celu, ponieważ jest dość powszechnym tworzeniem ofert dla stringów i int a nawet T, ale nigdy nie widziałem właściwości List Czy jest to nawet możliwe do zrobienia, tworząc właściwość dla Listy typów?

EDIT

mam normalną klasę, która ma właściwości normalne (właściwości ciągów, int właściwości itp) ale mam tę właściwość, która przechowuje opcje użytkownika, więc na warstwie prezentacji miałem przekształcić je w ciąg, dzięki któremu będę mógł je przechowywać w Obiekcie. Teraz możliwe jest posiadanie właściwości typu List, aby przechowywać wyniki wielowartościowe w lepszy i czysty sposób, zamiast konwertowania informacji na jeden ciąg znaków, a następnie podzielenia go i ponownego dołączenia do niego! Dzięki jeszcze raz = D

EDIT2

private List<KeyValuePair<string, string>> _settings; 

public List<KeyValuePair<string, string>> MySettings 
{ 
    get { return _settings; } 
    set { _settings = value; } 
} 

użyłem dokładnie kod zamieszczonych ale własność nadal nie pojawi się w instancji obiektu, więc próbowałem dodanie kodu do pobierania i ustawiania (I Zastanawiam się, dlaczego zostawiłeś je puste lub czy to coś znaczy?), a także dodałem zmienną prywatną w klasie, ale nadal nie pojawia się we właściwościach instancji obiektu!

Mam nadzieję, że możesz podać dokładny kod do wdrożenia tej właściwości i prosty kod, który przypisuje lub pobiera z instancji obiektu klasy Po raz pierwszy usłyszysz o tej KeyValuePair i wszystkie tutoriale są ładne proste, a nie w moim przypadku, przepraszam!

Ostatnia edycja: Po wielu poszukiwaniach i pomocy Marka Aveniusa znalazłem idealną odpowiedź. mam nadzieję, że każdy może z tego skorzystać.

TERAZ!Jak stworzyć BUDYNEK DO LISTY:

opcjach Class

Public Class Options 
{ 
     private string id; 
     private int option; 

     public int ID 
     { 
      get { return id; } 
      set { id= value; } 
     } 

     public string Option 
     { 
      get { return option; } 
      set { option = value; } 
     } 
} 

użytkowników Class

public class Users 

{ 
     private int userId; 
     private string pass; 
     private List<Options> userOptions = new List<Options>(); 


     public int ID 
     { 
      get { return userId; } 
      set { user = userId; } 
     } 

     public string Pass 
     { 
      get { return pass; } 
      set { pass = value; } 
     } 

     public List<Options> OptionsList 
     { 
      get { return userOptions; } 
      set { userOptions = value; } 
     } 
} 

warstwy prezentacji

Users newUser = new Users(); 
    Options userOption = new Options(); 

    userOption.ID = int.Parse(txtBxID.Text); 
    userOption.Option = txtBxOption.Text; 

    Item.Options.Add(userOption); 

Answer 1

T musi być zdefiniowany w zakresie i w którym pracujesz. W związku z tym, co napisali będzie działać, jeśli klasa jest nazwą rodzajową na T:

public class MyClass<T> 
{ 
    private List<T> newList; 

    public List<T> NewList 
    { 
     get{return newList;} 
     set{newList = value;} 
    } 
} 

przeciwnym wypadku trzeba użyć określonego typu.

EDIT: Na życzenie użytkownika @ lKashef, po to, jak mają właściwość listy:

private List<int> newList; 

public List<int> NewList 
{ 
    get{return newList;} 
    set{newList = value;} 
} 

To może iść w non-rodzajowego klasy.

Edit 2: W odpowiedzi na drugie pytanie (w edycji), nie polecam na podstawie listy dla tego rodzaju przetwarzania danych (jeśli ja cię rozumie poprawnie). Chciałbym umieścić ustawienia użytkownika w ich własnej klasy (lub struct, jeżeli chcesz) i mają właściwość tego typu na oryginalnym Klasa:

public class UserSettings 
{ 
string FirstName { get; set; } 
string LastName { get; set; } 
// etc. 
} 

public class MyClass 
{ 
string MyClassProperty1 { get; set; } 
// etc. 

UserSettings MySettings { get; set; } 
} 

ten sposób zostały nazwane właściwości, które można odwoływać zamiast dowolny indeks na liście. Na przykład można odwoływać się do MySettings.FirstName w przeciwieństwie do MySettingsList[0].

Daj mi znać, jeśli masz dodatkowe pytania.

EDIT 3: Na pytania w komentarzach, nieruchomość będzie tak:

public class MyClass 
{ 
    public List<KeyValuePair<string, string>> MySettings { get; set; } 
} 

EDIT 4: opiera się na pytaniu za edit 2, następuje, jak bym to wykorzystać :

public class MyClass 
{ 
    // note that this type of property declaration is called an "Automatic Property" and 
    // it means the same thing as you had written (the private backing variable is used behind the scenes, but you don't see it) 
    public List<KeyValuePair<string, string> MySettings { get; set; } 
} 

public class MyConsumingClass 
{ 
    public void MyMethod 
    { 
     MyClass myClass = new MyClass(); 
     myClass.MySettings = new List<KeyValuePair<string, string>>(); 
     myClass.MySettings.Add(new KeyValuePair<string, string>("SomeKeyValue", "SomeValue")); 

     // etc. 
    } 
} 

Wspomniał Pan, że "nieruchomość nadal nie pojawi się w instancji obiektu" i nie jestem pewien co masz na myśli. Czy ta właściwość nie pojawia się w IntelliSense?Czy jesteś pewien, że utworzyłeś instancję MyClass (np. myClass.MySettings powyżej), czy próbujesz uzyskać do niej dostęp jak nieruchomość statyczną (np. MyClass.MySettings)?

Answer 2

public class MyClass<T> 
{ 
    private List<T> list; 

    public List<T> MyList { get { return list; } set { list = value; } } 
} 

Następnie można zrobić coś takiego

MyClass<int> instance1 = new MyClass<int>(); 
List<int> integers = instance1.MyList; 

MyClass<Person> instance2 = new MyClass<Person>(); 
IEnumerable<Person> persons = instance2.MyList; 

Answer 3

Można to zrobić, ale ogólny parametr T musi być zadeklarowana w zawierającego klasę:

public class Foo<T> 
{ 
    public List<T> NewList { get; set; } 
} 

Answer 4

Możliwe jest posiadanie właściwości typu List<T>, ale należy również przekazać klasę T.

public class ClassName<T> 
{ 
    public List<T> MyProperty { get; set; } 
} 

Answer 5

Albo określić typ T, lub jeśli chcesz zrobić to ogólne, trzeba uczynić klasy nadrzędnej rodzajowy.

public class MyClass<T> 
{ 
    etc 

Answer 6

Prosta i skuteczna alternatywa:

public class ClassName 
{ 
    public List<dynamic> MyProperty { get; set; } 
} 

lub

public class ClassName 
{ 
    public List<object> MyProperty { get; set; } 
} 

Dla różnic zobaczyć ten wpis: List<Object> vs List<dynamic>