Come può un UserControl WPF ereditare un UserControl WPF?

Il seguente UserControl WPF chiamato DataTypeWholeNumber che funziona.

Ora voglio creare un UserControl chiamato DataTypeDateTime e DataTypeEmail , ecc.

Molte delle proprietà di dipendenza saranno condivise da tutti questi controlli e quindi desidero inserire i loro metodi comuni in un BaseDataType e fare in modo che ciascuno di questi controlli utente erediti da questo tipo di base.

Tuttavia, quando lo faccio, ottengo l' errore: la dichiarazione parziale potrebbe non avere classi di base diverse .

Quindi come posso implementare l'ereditarietà con UserControls in modo che la funzionalità condivisa sia tutta nella classe base?

using System.Windows;
using System.Windows.Controls;

namespace TestDependencyProperty827.DataTypes
{
    public partial class DataTypeWholeNumber : BaseDataType
    {
        public DataTypeWholeNumber()
        {
            InitializeComponent();
            DataContext = this;

            //defaults
            TheWidth = 200;
        }

        public string TheLabel
        {
            get
            {
                return (string)GetValue(TheLabelProperty);
            }
            set
            {
                SetValue(TheLabelProperty, value);
            }
        }

        public static readonly DependencyProperty TheLabelProperty =
            DependencyProperty.Register("TheLabel", typeof(string), typeof(BaseDataType),
            new FrameworkPropertyMetadata());


        public string TheContent
        {
            get
            {
                return (string)GetValue(TheContentProperty);
            }
            set
            {
                SetValue(TheContentProperty, value);
            }
        }

        public static readonly DependencyProperty TheContentProperty =
            DependencyProperty.Register("TheContent", typeof(string), typeof(BaseDataType),
            new FrameworkPropertyMetadata());


        public int TheWidth
        {
            get
            {
                return (int)GetValue(TheWidthProperty);
            }
            set
            {
                SetValue(TheWidthProperty, value);
            }
        }

        public static readonly DependencyProperty TheWidthProperty =
            DependencyProperty.Register("TheWidth", typeof(int), typeof(DataTypeWholeNumber),
            new FrameworkPropertyMetadata());



    }
}

Assicurati di aver modificato il primo tag in xaml per ereditare anche dal tuo nuovo tipo di base

Così

<UserControl x:Class="TestDependencyProperty827.DataTypes.DataTypeWholeNumber"
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"        
    xmlns:s="clr-namespace:System;assembly=mscorlib"
    >

diventa

<myTypes:BaseDataType x:Class="TestDependencyProperty827.DataTypes.DataTypeWholeNumber"
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"        
    xmlns:s="clr-namespace:System;assembly=mscorlib"
    xmlns:myTypes="clr-namespace:TestDependencyProperty827.DataTypes"
    >

Quindi, per riassumere la risposta completa inclusi i dettagli extra dai commenti di seguito:

• La classe base non dovrebbe includere un file xaml. Definiscilo in un singolo file cs (non parziale) e definiscilo in modo che erediti direttamente da Usercontrol.
• Assicurati che la sottoclasse erediti dalla classe base sia nel file code-behind cs che nel primo tag di xaml (come mostrato sopra).

public partial class MooringConfigurator : MooringLineConfigurator
    {
        public MooringConfigurator()
        {
            InitializeComponent();
        }
    }



<dst:MooringLineConfigurator x:Class="Wave.Dashboards.Instruments.ConfiguratorViews.DST.MooringConfigurator"
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
    xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
    xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
    xmlns:dst="clr-namespace:Wave.Dashboards.Instruments.ConfiguratorViews.DST"
    mc:Ignorable="d"
    d:DesignHeight="300" d:DesignWidth="400">

    <Grid x:Name="LayoutRoot" Background="White">

    </Grid>
</dst:MooringLineConfigurator>    

Ho trovato la risposta in questo articolo: http://www.paulstovell.com/xmlnsdefinition

Fondamentalmente ciò che viene detto è che dovresti definire uno spazio dei nomi XML nel file AssemlyInfo.cs, che può essere utilizzato in XAML. Ha funzionato per me, tuttavia ho inserito la classe di controllo utente di base in una DLL separata ...

Mi sono imbattuto nello stesso problema ma avevo bisogno che il controllo ereditasse da una classe astratta, che non è supportata dal designer. Ciò che ha risolto il mio problema è stato far ereditare da usercontrol sia una classe standard (che eredita UserControl) che un'interfaccia. In questo modo il designer sta lavorando.

//the xaml
<local:EcranFiche x:Class="VLEva.SIFEval.Ecrans.UC_BatimentAgricole" 
                  xmlns:local="clr-namespace:VLEva.SIFEval.Ecrans"
                  ...>
    ...
</local:EcranFiche>

// the usercontrol code behind
public partial class UC_BatimentAgricole : EcranFiche, IEcranFiche
{
    ...
}

// the interface
public interface IEcranFiche
{
   ...
}

// base class containing common implemented methods
public class EcranFiche : UserControl
{
    ... (ex: common interface implementation)
}

Esiste una definizione di classe parziale creata dal designer, è possibile aprirla in modo semplice tramite la definizione del metodo InitializeComponent (). Quindi cambia semplicemente l'ereditarietà della classe parziale da UserControl a BaseDataType (o qualsiasi altra specificata nella definizione della classe).

Dopodiché avrai un avviso che il metodo InitializeComponent () è nascosto nella classe figlia.

Pertanto è possibile creare un CustomControl come classe di base invece di UserControl per evitare una definizione parziale nella classe base (come descritto in un commento).