c# - controles - ¿Cómo puede un UserControl de WPF heredar un UserControl de WPF?

custom control wpf

Question

El siguiente UserControl de WPF llamó a DataTypeWholeNumber que funciona.

Ahora quiero hacer un UserControl llamado DataTypeDateTime y DataTypeEmail , etc.

Muchas de las Propiedades de Dependencia serán compartidas por todos estos controles y, por lo tanto, quiero poner sus métodos comunes en un BaseDataType y hacer que cada uno de estos UserControls herede de este tipo base.

Sin embargo, cuando lo hago, aparece el error: la Declaración parcial puede no tener diferentes clases base .

Entonces, ¿cómo puedo implementar la herencia con UserControls para que la funcionalidad compartida esté en la clase 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

Asegúrese de haber cambiado la primera etiqueta en el xaml para heredar también de su nuevo tipo de base

Asi que

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

se convierte

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

Por lo tanto, para resumir la respuesta completa, incluidos los detalles adicionales de los comentarios a continuación:

• La clase base no debe incluir un archivo xaml. Defínelo en un único archivo cs (no parcial) y defínalo para que herede directamente de Usercontrol.
• Asegúrese de que la subclase hereda de la clase base tanto en el archivo de código subyacente cs como en la primera etiqueta de xaml (como se muestra arriba).

Answer 2

Encontré la respuesta en este artículo: http://www.paulstovell.com/xmlnsdefinition

Básicamente, lo que se dice es que debe definir un espacio de nombres XML en el archivo AssemlyInfo.cs, que se puede usar en XAML. Me funcionó, sin embargo, coloqué la clase de control de usuario base en una DLL separada ...

Answer 3

Hay una definición de clase parcial creada por el diseñador, puede abrirla de manera fácil a través de la definición del método InitializeComponent (). Luego, simplemente cambie la legitimidad de clase parcial de UserControl a BaseDataType (o cualquiera que haya especificado en la definición de clase).

Después de eso, advertirá que el método InitializeComponent () está oculto en la clase secundaria.

Por lo tanto, puede hacer un CustomControl como base clas en lugar de UserControl para evitar la definición parcial en la clase base (como se describe en un comentario).

Answer 4

Me encontré con el mismo problema, pero necesitaba tener el control heredado de una clase abstracta, que no es compatible con el diseñador. Lo que resolvió mi problema es hacer que el control de usuario herede de una clase estándar (que hereda UserControl) y una interfaz. De esta manera, el diseñador está trabajando.

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

Answer 5

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>