ObservableCollection<Klasa<T>> jak zaimplementować

Czy da się zaimplementować coś takiego?

class Klasa<T>
    {
        public int prop1 { get; set; }
        public T prop2 { get; set; }

    }

bool aaa = true;
ObservableCollection<Klasa<string>> oc1 = new ObservableCollection<Klasa<string>>();
ObservableCollection<Klasa<int>> oc2 = new ObservableCollection<Klasa<int>>();

var oc3 = new ObservableCollection<Klasa<string>>(); //???
if(aaa)
{
oc3 = oc1;
}
else oc3 = oc2;

Chcę stworzyć kolekcję która w zależności od warunków będzie posiadać elementy określonego typu. Czy jest to możliwe?
Proszę o wskazówki.

http://stackoverflow.com/questions/12545270/how-can-i-add-an-observablecollectionclasst-use-inheritance-for-t

Dziękuję za link.

Szczerze mówiąc nie potrafię przełożyć tego przykładu na mój problem. Zakładam, że obiekty, które będą podstawiane pod T nie mogą dziedziczyć po jednej klasie lub interfejsie, ani też po sobie.

LukKow napisał(a):

Zakładam, że obiekty, które będą podstawiane pod T nie mogą dziedziczyć po jednej klasie lub interfejsie, ani też po sobie.

A po Object nie dziedziczą?

Są to obiekty różnych klas, których property będą potem bindowane do kontrolki.

OK.

Mam kilka kolekcji w każdej obiekty innej klasy. W zależności od parametru zewnętrznego do combo chcę ładować inną kolekcję. Jest to WPF-owy ComboBox.

C#

    public class first
    {
        public string imie{get; set;}
        public string nazwisko{get; set;}
    }
    public class second
    {
        public int nr_konta{get; set;}
        public int id_klienta{get; set;}
    }

    public partial class test : Window
    {
        private ObservableCollection<first> first_lista;
        private ObservableCollection<second> second_lista;
        public test()
        {
            first_lista = new ObservableCollection<first> { new first { imie = "jan", nazwisko = "kowalski" } };
            second_lista = new ObservableCollection<second> { new second { nr_konta = 1, id_klienta = 166 } };
            InitializeComponent();
            this.DataContext = this;
            int wybor = 0;
            if (wybor == 0)
            {
                combobox.ItemsSource = first_lista;
                combobox.ItemTemplate = combobox.Resources["temp_first"] as DataTemplate;
            }
            else if(wybor == 1)
            {
                combobox.ItemsSource = second_lista;
                combobox.ItemTemplate = (drugi szablon zdefiniowany)
            }
        }
    } 

WPF

 <ComboBox Name="combobox">
            <ComboBox.Resources>
                <DataTemplate x:Key="temp_first">
                    <StackPanel Orientation="Horizontal">
                    <TextBlock Text="{Binding imie, StringFormat=Imie: {0} }"/>
                    <TextBlock Margin="5,0,0,0" Text="{Binding nazwisko, StringFormat=Nazwisko: {0}}"/>
                    </StackPanel>
                </DataTemplate>
            </ComboBox.Resources>
         </ComboBox> 

Wystarczy utworzyć kolejne szablony danych, pierwszy zrobiłem dla przykładu odnosiłby się do listy first_lista.
Edit w samym kodzie xaml, bez sprawdzania w kodzie behind wartości wyboru.

<ComboBox Name="combobox">
            <ComboBox.Resources>
                <DataTemplate x:Key="temp_first">
                    <StackPanel Orientation="Horizontal">
                        <TextBlock Text="{Binding imie, StringFormat=Imie: {0} }"/>
                        <TextBlock Margin="5,0,0,0" Text="{Binding nazwisko, StringFormat=Nazwisko: {0}}"/>
                    </StackPanel>
                </DataTemplate>
            </ComboBox.Resources>
            <ComboBox.Style>
                <Style TargetType="ComboBox">
                    <Style.Triggers>
                        <DataTrigger Binding="{Binding wybor}" Value="0">
                            <Setter Property="ItemTemplate" Value="{StaticResource temp_first}"/>
                        </DataTrigger>
                    </Style.Triggers>
                </Style>
            </ComboBox.Style>  
         </ComboBox> 

You're good!!!

Wielkie dzięki za pomoc :)

Jeśli Twoja wartość według której miałby się zmieniać szablon danych była wartością statyczną klasy statycznej żebyś nie musiał odwoływać się poprzez Tworzenie obiektu albo chciałbyś zmieniać szablon danych np. według typu obiektu w Liście to możesz wykorzystać mechanizm SelectorItemTemplate
C#

 class selector:DataTemplateSelector
    {
        public override DataTemplate SelectTemplate(object item, System.Windows.DependencyObject container)
        {
            if (item is student) return Template1;
// albo if(klasa_statyczna.zmienna_statyczna == 0) return Template1...
            else return Template2;
        }
        public DataTemplate Template1 { get; set; }
        public DataTemplate Template2 { get; set; }
    }

WPF

  
mapujesz na przestrzeń
<Window...
xmlns:selector="clr-namespace:WpfApplication1.Views">
    <Window.Resources>
        <DataTemplate x:Key="one">
            <TextBlock Text="student"/>
        </DataTemplate>
        <DataTemplate x:Key="two">
            <TextBlock Text="nie_student"/>
        </DataTemplate>
        <selector:selector x:Key="selector" Template1="{StaticResource one}" Template2="{StaticResource two}"/>
    </Window.Resources>
       <ListBox ItemsSource="{Binding lista}" ItemTemplateSelector="{StaticResource selector}"/>

Jeśli obiekty w klasie są klasy student to przypisany zostanie szablon one, w przeciwnym wypadku szablon o nazwie two.