Ableiten von UserControls

Hallo zusammen,

ich bin gerade dabei in das Thema WPF einzusteigen. Vieles hab ich schon hinbekommen (wenn es auch teilweise echt umständlich ist im Gegensatz zu Win Forms). Nur beim Ableiten von Controls hab ich noch Probleme. Ich weiß mitlerweile das ein UserControl mit Xaml nicht von einem anderen UserControl mit Xaml ableiten kann. Jedoch habe ich gelesen das ich von einem UserControl ohne Xaml ableiten kann. Deshalb hab ich folgendes versucht:

Basisklasse:

namespace Testprojekt
{
    public class UCBase : UserControl
    {
        public UCBase():base()
        {
            Grid tmpGrid = new Grid();
            tmpGrid.HorizontalAlignment = System.Windows.HorizontalAlignment.Stretch;
            tmpGrid.VerticalAlignment = System.Windows.VerticalAlignment.Stretch;
            tmpGrid.Background = System.Windows.Media.Brushes.Blue;
            this.Content = tmpGrid;
        }
    }
}

Abgeleitete Klasse:

<myTypes:UCBase x:Class="Testprojekt.UCInherit"
             xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
             xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
             xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006" 
             xmlns:d="http://schemas.microsoft.com/expression/blend/2008" 
             mc:Ignorable="d" 
             d:DesignHeight="284" d:DesignWidth="338"
             xmlns:myTypes="clr-namespace:Testprojekt">
    <Grid>

    </Grid>
</myTypes:UCBase>

namespace Testprojekt
{
    public partial class UCInherit: UCBase
    {
        public UCInherit()
        {
            InitializeComponent();
        }
    }
}

Ich habe nun gedacht wenn ich das UCInherit öffne das ich nen Blauen Hintergrund von meinem Basis-UserControl sehe, aber Pustekuchen. Irgendwie ignoriert er alle Controls die im Konstruktor des Basis-UserControls erstelle. Hat jemand ne Idee wieso?

Gruß

Maruu

Probier mal das hier:

namespace Testprojekt
{
    public class UCBase : UserControl
    {
        public UCBase():base()
        {

        }
static UCBase()
{
BackgroundProperty.OverrideMetadata(typeof(UCBase ), new FrameworkPropertyMetadata(Brushes.Blue));

}
    }
}

Im UserControl must du jetzt auf die Background Property Binden. Z.B. so

<myTypes:UCBase x:Class="Testprojekt.UCInherit"
              xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
              xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
              xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
              xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
              mc:Ignorable="d"
              d:DesignHeight="284" d:DesignWidth="338"
              xmlns:myTypes="clr-namespace:Testprojekt">
<myTypes:UCBase.Content>
     <Grid Background=="{Binding Path=Background,
	            RelativeSource={RelativeSource Mode=FindAncestor,AncestorType={x:Type local:UCInherit}}}" >
 
    </Grid></myTypes:UCBase.Content>
 </myTypes:UCBase>

Mhhhm, das Problem ist das Grid im abgeleiteten UserControl. Wenn ich das mache:

<myTypes:UCBase x:Class="Testprojekt.UCInherit"
             xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
             xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
             xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006" 
             xmlns:d="http://schemas.microsoft.com/expression/blend/2008" 
             mc:Ignorable="d" 
             d:DesignHeight="284" d:DesignWidth="338"
             xmlns:myTypes="clr-namespace:Testprojekt">

</myTypes:UCBase>

Dann geht es. Nur kann ich jetzt lediglich ein Element auf dem Usercontrol platzieren. Wenn ich das Grid drin lasse und den hintergrund auf transparent setze geht es leider auch nicht. Hat jemand ne Idee wie man das lösen kann?

Gruß

Maruu

Hallo,

da ich nicht genau weiß was du vor hast hier noch folgendes als Ergänzung. In WPF gibt es Custom Controls und User Controls.

-UserControls soll man verwenden wenn man mehrere Control zu einem Control gruppieren möchte, um Komplexität zu kapseln, oder um die gruppierten Controls auf an mehreren Stellen wieder zu verwenden.
-keine Visuelle Anpassung benötigt wird

Custom Controls unterstützen Templates und Themes.

Hier ein Beispiel:
Wir möchten ein Control erstellen das eine Uhr darstellt. -> Custom Control.
Wir brauchen ein Control das aus TextBlock und TextBox besteht ->UserControl.

Wenn du ein BaseControl erstellst welches von UserControl erbt, und ein ExtendedControl das wiederum von BaseControl erbt, erbst du nur die in der Klasse definierten Funktionalitäten (Also keine Visuellen Eigenschaften).

Im ExtentdedControl must du im XAML auf die Propertie von BaseControl binden. Dann sollte das gehen.

Danke für die Antwort. Um genau zu sein möchte ich später folgendes haben:

Ich benötige ein Control (egal ob CustomControl oder UserControl) das einen blauen Hintergrund und einen roten Rahmen hat. Nun will ich von diesem Basiscontrol ableiten, eine Ableitung soll dann noch auf dem Control eine Uhr Platzieren, eine andere Ableitung soll auf dem Control eine Textbox platzieren. Zum Schluss sollen von diesen Ableitung Instanzen erstellt werden und diese Instanzen dann auf einem Window platziert werden.

Es soll also zum Schluss ein Window geben in dem mehrere dieser Blauen Controls mit rotem Rand sind und auf jedem dieser Quadrate ist noch ein Control (wie erwähnt eine Uhr, eine Textbox usw.).

Welches Vorgehen empfiehlt sich hier, Ableiten von einer Baisklasse und wenn ja von einem Control oder UserControl? Oder doch anders?

Gruß

Maruu

Hallo,

auf jedenfall anders 😃

Ich benötige ein Control (egal ob CustomControl oder UserControl) das einen blauen Hintergrund und einen roten Rahmen hat. So darf man das in WPF nicht sagen. Controls in WPF definieren sich einzig und allein über die Funktionalität, in deinem Fall, kann ein bestimmten Inhalt aufnehmen. Niemals über das Aussehen. Das ist beliebig in WPF.

Was die Funktionalität angeht ist klar was du brauchst: ein ContentControl. Da kannst du reinpacken was du willst. Was du zusätzlich benötigst ist einfach nur ein Template mit Styles welches dein gewolltes Aussehen definiert.

Jetzt brauchst du nur an den Stellen wo du es benötigst ein ContentControl einfügen, dem das Template mitgeben und den Inhalt und fertig ist die Sache.

In WPF ist ableiten von Basisklassen der völlig falsche Weg für das was du vorhast.