A binding for generic objects in a specific scenario

[chis-optimus]

I have a generic subclass that contains a generic property, and this class inherits from a base class. When I try to build a binding source, due to the generic nature of its subclass, I can only construct a collection of its base class. code like this:

public abstract class BaseClass : INotifyPropertyChanged { public event PropertyChangedEventHandler? PropertyChanged; private DataType dataType; //i8、i32、i64、byte[] [BsonId(autoId: true)] public int Id { get; init; } } public class SubClass : BaseClass { private T reVal; [BsonIgnore] public T ReVal { get { return reVal; } set { SetProperty(ref reVal,value); } } }

Next, my ViewModel is implemented like this：

public partial class MainWindowViewModel : ObservableObject {
[ObservableProperty] private ObservableCollection baseObjects = [];
public MainWindowViewModel() {
BaseClass i32Object = new SubClass() {
Tag = $"Int Eob{i}"
};
i32Object .SetDataType(DataType.I32);
BaseObjects .Add(i32Object );
BaseClass blobObject= new SubClass<byte[]>() {
Tag = "Blob Eob"
};
blobObject.SetDataType(DataType.Blob);
BaseObjects .Add(blobObject);
}
}

In WPF, I can bind like this, and it works very well.
<ListBox ItemsSource="{Binding BaseObjects }"> <ListBox.ItemTemplate> <DataTemplate> <StackPanel Orientation="Horizontal"> <StackPanel.Resources> <Style TargetType="TextBlock"> <Setter Property="Margin" Value="8,4" /> </Style> </StackPanel.Resources> <TextBlock Text="{Binding Tag}" /> <TextBlock Text="{Binding DataType}" /> <TextBlock Text="{Binding HoldBytes}" /> <TextBlock Text="{Binding ReVal, Converter={StaticResource ByteArrayToHexStringConverter}}" /> </StackPanel> </DataTemplate> </ListBox.ItemTemplate> </ListBox>

But for the generic property ReVal in the subclass, if the listbox is directly bound to BaseObjects, it cannot recognize the ReVal property of its subclass. Is there any way to bind to the subclass property?

[timunie]

Maybe you can implement a non generic interface to use here?

[stevemonaco]

This is because WPF uses reflection to resolve bindings. You could instead use {ReflectionBinding ReVal, ...} in Avalonia, but it closes off some avenues and reduces perf / compile-time safety.

You can't bind to open generics, especially in this way. You're binding to a BaseClass which doesn't even have a ReVal member so how could Avalonia guarantee that it's available let alone differentiate the T at compile-time for every potential subclass?

[IanRawley]

You can sort of do this with DataTemplates. You'll need to make specific DataTemplates for each datatype, which can get messy, but does work unless you intend the generic to be unbounded.

Looks a little like this, although I haven't worried about making sure the namespaces are correct, nor the exact syntax for the System types Int/Byte[]. This should give you an idea of how to make it work though.

<ListBox.DataTemplates>
   <DataTemplate x:DataType="BaseClass">
     <StackPanel Orientation="Horizontal"> 
        <TextBlock Text="{Binding Tag}" /> 
        <TextBlock Text="{Binding DataType}" /> 
        <TextBlock Text="{Binding HoldBytes}" /> 
        <ContentControl Content={Binding}>
           <ContentControl.DataTemplates>
              <DataTemplate>
                <DataTemplate.DataType>
                   <x:Type TypeName="SubClass" x:TypeArguments="Int"/>
                </DataTemplate.DataType>
                <TextBlock Text="{Binding ReVal, Converter={StaticResource ByteArrayToHexStringConverter}}" />
             </DataTemplate>
             <DataTemplate>
                <DataTemplate.DataType>
                   <x:Type TypeName="SubClass" x:TypeArguments="Byte[]"/>
                </DataTemplate.DataType>
                <TextBlock Text="{Binding ReVal, Converter={StaticResource ByteArrayToHexStringConverter}}" />
             </DataTemplate>
           </ContentControl.DataTemplates>
        </ContentControl>   
    </StackPanel>
  </DataTemplate>
</ListBox.DataTemplates>

[chis-optimus]

You can sort of do this with DataTemplates. You'll need to make specific DataTemplates for each datatype, which can get messy, but does work unless you intend the generic to be unbounded.

Looks a little like this, although I haven't worried about making sure the namespaces are correct, nor the exact syntax for the System types Int/Byte[]. This should give you an idea of how to make it work though.

<ListBox.DataTemplates>
   <DataTemplate x:DataType="BaseClass">
     <StackPanel Orientation="Horizontal"> 
        <TextBlock Text="{Binding Tag}" /> 
        <TextBlock Text="{Binding DataType}" /> 
        <TextBlock Text="{Binding HoldBytes}" /> 
        <ContentControl Content={Binding}>
           <ContentControl.DataTemplates>
              <DataTemplate>
                <DataTemplate.DataType>
                   <x:Type TypeName="SubClass" x:TypeArguments="Int"/>
                </DataTemplate.DataType>
                <TextBlock Text="{Binding ReVal, Converter={StaticResource ByteArrayToHexStringConverter}}" />
             </DataTemplate>
             <DataTemplate>
                <DataTemplate.DataType>
                   <x:Type TypeName="SubClass" x:TypeArguments="Byte[]"/>
                </DataTemplate.DataType>
                <TextBlock Text="{Binding ReVal, Converter={StaticResource ByteArrayToHexStringConverter}}" />
             </DataTemplate>
           </ContentControl.DataTemplates>
        </ContentControl>   
    </StackPanel>
  </DataTemplate>
</ListBox.DataTemplates>

Thank you very much for your suggestion. I will try the method you provided, although I have already solved this problem using the DataTemplateSelector approach.

[chis-optimus]

I tried it with basic types like string, int32, int64, byte, int16, and it worked fine, but I couldn't find a suitable TypeArguments for arrays. I tried x: Byte[] and x: Array, but both failed.
under way is OK
<x:Type TypeName="SubClass" x:TypeArguments="x:Int32"/>
<x:Type TypeName="SubClass" x:TypeArguments="x:Int64"/>
....
it does'nt work!
<x:Type TypeName="SubClass" x:TypeArguments="x:Byte[]"/>
<x:Type TypeName="SubClass" x:TypeArguments="x:Array"/>

[IanRawley]

I haven't tried it, but WPF docs suggest something like this, which may work:

<x:Type TypeName="SubClass" x:TypeArguments="x:Array(x:Byte)"/>

[chis-optimus]

If it can be implemented in the way you suggested, it would be perfect for me, but unfortunately, the only issue is that it still doesn't work.
<x:Type TypeName="SubClass" x:TypeArguments="x:Array(x:Byte)"/>
I have already tried.