Comment un utilisateur WPF UserControl peut-il hériter d'un utilisateur WPF UserControl?

Question

La suite de WPF UserControl appelé DataTypeWholeNumber qui fonctionne.

Maintenant, je veux faire un UserControl appelé DataTypeDateTime et DataTypeEmail, etc.

De nombreuses Propriétés de Dépendance sera partagé par l'ensemble de ces contrôles et, par conséquent, je veux mettre en commun les méthodes dans un BaseDataType et ont chacun de ces UserControls héritent de ce type de base.

Cependant, lorsque je fais cela, j'obtiens l' erreur: Déclaration Partielle ne peut avoir différentes classes de base.

Alors, comment puis-je mettre en œuvre l'héritage avec UserControls donc partagé fonctionnalité est tous dans la classe de 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());



    }
}

Answer 1

S'assurer que vous avez changé la première balise dans le code xaml également hériter de votre nouveau basetype

Donc

<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"
    >

devient

<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"
    >

---

Donc, pour résumer la réponse complète, y compris les informations supplémentaires à partir des commentaires ci-dessous:

• La classe de base ne devrait pas inclure un fichier xaml. Le définir en un seul (et non partielle) cs fichier et de le définir d'hériter directement de Usercontrol.
• S'assurer que la sous-classe hérite de la classe de base à la fois dans le cs fichier code-behind et dans la première balise de la xaml (comme illustré ci-dessus).

Answer 2

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>    

Answer 3

J'ai trouvé la réponse dans cet article: http://www.paulstovell.com/xmlnsdefinition

En gros, il est conseillé de définir un espace de noms XML dans le fichier AssemlyInfo.cs, qui peut être utilisé dans le code XAML. Cela a fonctionné pour moi, cependant j'ai placé la classe de contrôle utilisateur de base dans une DLL séparée ...

Answer 4

J'ai rencontré le même problème, mais le contrôle devait hériter d'une classe abstraite, qui n'est pas prise en charge par le concepteur. Ce qui a résolu mon problème, c'est que usercontrol hérite à la fois d'une classe standard (qui hérite de UserControl) et d'une interface. De cette façon, le concepteur travaille.

 //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)
}