none
WPF Datenaustasuch zwischen Usercontrol RRS feed

  • Frage

  • Hallo Welt, - WPF Anwendung !

    zuerst einmal Vielen Dank an alle die antworten und auch an die, die meine bisherigen Fragen beantwortet haben.

    Bei meiner frage geht es um Daten die ich ich Parent aufwärts zu einem anderen Parent abwärts übergeben möchte.

    Mir ist klar, dass ich über ein modul gemeinsam Daten verwenden kann. Wie ist es aber wenn ich zu einem anderen Usercontrol Daten übergeben möchte ?

    <TabControl TabStripPlacement="Bottom">
                <TabItem Header="Anton">
                    <local:ucBerta x:Name="usercontrolB" Parentname="Berta"/>
                </TabItem>
                <TabItem Header="Berta" >
                        <local:ucCaesar x:Name="usercontrolC" Parentname="Cäsar"/>
               
                            </TabItem>
                <TabItem Header="Cäsar" >
                         <local:ucDora x:Name="usercontrolD" Parentname="Dora"/>
    ......        

    In usercontrolB ist ein Grid mit usercontrolChildren mit Objeckten. 

    Von diesem usercontrol möchte ich nun eine Function aufruden, die im Grid des usercontrolC und in dessem grid ein children add durchführt, indem ich eine sub/function in usercontrolC ausführe.

    Ich versuche es grafisch

    Mainwindow

    Tabcontrol

    Tabitem                     Tabitem                        Tabitem

    Usercontrol                Usercotrol                     Usercontrol
    Grid.children              grid.children                 Grid.children

    Hier werte nach --------------------------------->

    ein Parentaufruf reicht nicht. Ich wollte die Daten schon zwischenspeichern

    nach dem Motto schreiben/lesen.

    Ich hoffe meine Frage ist verständlich ??


    Bernhard Meyer Danke


    Montag, 12. April 2021 09:44

Antworten

  • Hallo Bernhard!

    Wie immer hat Peter natürlich grundsätzlich recht. Der heilige Gral in WPF ist MVVM. Damit musst du dich auseinandersetzen, wenn du effektiv in WPF weiter gehen möchtest.

    Für dein erstes Verständnis möchte ich dir aber auch noch einen Lösungsweg zeigen.

    Das Prinzip beruht auf folgender Vorgehensweise:

    1. In dem UserControl in dem du etwas auslösen möchtest, eigentlich egal was (in deinem Beispiel ein Objekt in einem anderen Usercontrol erstellen) (=UserControlA), musst du ein Event implementieren, dass ausgelöst wird, wenn du /der Benutzer es möchte. (Ich habe einfach eine Schaltfläche gewählt.)

    2. In dem UserControl in dem du eine Aktion ausführen möchtest (=UserControlB), musst du eine Methode, die diese Aktion ausführt, implementieren.

    3. Auf dem Window auf dem die Instanzen der UserControl sind (= GUI) musst du  

    das Event, das im UserControlA ausgelöst wird, abonnieren und in dessen Event-Behandlungsroutine die Aktionsausführungs-Methode von UserControlB aufrufen.

    Kurz: UserControlA feuert ein Event und UserControlB führt die gewünschte Aktion aus, da es das Event abonniert.

    Durch definieren von eigenen EventArgumenten kannst du auch beliebige Parameter mit übergeben. Ich habe das im Beispiel bei der Erstellung der Ellipsen mal demonstriert.

    GUI

    <Window x:Class="UC_Daten_Uebernahme.MainWindow"
            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:local="clr-namespace:UC_Daten_Uebernahme"
            mc:Ignorable="d"
            Title="MainWindow" Height="350" Width="525">
        <Grid>
            <Grid.RowDefinitions>
                <RowDefinition/>
                <RowDefinition/>
            </Grid.RowDefinitions>
            <local:UserControlA x:Name="UserControlA" Margin="10"
                           Erstell_Label="UsercontrolB_Erstell_Label" 
                           Erstell_Ellipse="UsercontrolB_Erstell_Ellipse"/>
            <local:UserControlB Grid.Row="2" x:Name="UserControlB" Margin="10"/>
        </Grid>
    </Window>
    
    using System.Windows;
    
    namespace UC_Daten_Uebernahme
    {
        /// <summary>
        /// Interaktionslogik für MainWindow.xaml
        /// </summary>
        public partial class MainWindow : Window
        {
            public MainWindow()
            {
                InitializeComponent();
            }
    
            private void UsercontrolB_Erstell_Label(object sender, RoutedEventArgs e)
            {
                UserControlB.Add_Label();        // Eine Methode ausführen, die durch ein Event ausgelöst wurde. 
            }
    
            private void UsercontrolB_Erstell_Ellipse(object sender, RoutedEventArgs e)
            {
                EllipseErstellenEventArgs ellipseErstellenEventArgs = (EllipseErstellenEventArgs)e;     // Standard-EventArgs in EllipseErstellenEventArgs konvertieren, um auf die zusätzlich definierten Eigenschaften zugreifen zu können.
    
                UserControlB.Add_Ellipse(ellipseErstellenEventArgs.BrsEllipsenFarbe, ellipseErstellenEventArgs.DblGroesse);
            }
        }
    }
    


    UserControl's

    (UserControlA) -> Löst Event aus

    <UserControl x:Class="UC_Daten_Uebernahme.UserControlA"
                 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" 
                 xmlns:local="clr-namespace:UC_Daten_Uebernahme"
                 mc:Ignorable="d" 
                 d:DesignHeight="300" d:DesignWidth="300" Background="LightGray">
        <Grid>
            <Label Content="UserControlA" FontWeight="Bold" />
            <StackPanel VerticalAlignment="Center" >
                <Button x:Name="BtnMake_Label" Content="Erstelle Label" Click="BtnMake_Label_Click" Margin="10" />
                <DockPanel>
                    <Rectangle DockPanel.Dock="Right" MinWidth="20" MinHeight="20" Fill="Red" VerticalAlignment="Center" Margin="0,0,3,0" MouseLeftButtonDown="Rectangle_MouseLeftButtonDown"/>
                    <Rectangle DockPanel.Dock="Right" MinWidth="20" MinHeight="20" Fill="Green" VerticalAlignment="Center" Margin="0,0,3,0" MouseLeftButtonDown="Rectangle_MouseLeftButtonDown"/>
                    <Rectangle DockPanel.Dock="Right" MinWidth="20" MinHeight="20" Fill="Yellow" VerticalAlignment="Center" Margin="0,0,3,0" MouseLeftButtonDown="Rectangle_MouseLeftButtonDown"/>
                    <TextBox DockPanel.Dock="Right" Text="30" MinHeight="20" VerticalAlignment="Center" x:Name="TboGroesse" Margin="0,0,5,0" />
                    <Button x:Name="BtnMake_Ellipse" Content="Erstelle Ellipse" Click="BtnMake_Ellipse_Click" Margin="10,10,5,10" />
                </DockPanel>
            </StackPanel>
        </Grid>
    </UserControl>
    
    using System.Windows;
    using System.Windows.Controls;
    using System.Windows.Media;
    
    namespace UC_Daten_Uebernahme
    {
        /// <summary>
        /// Interaktionslogik für ucBerta.xaml
        /// </summary>
        public partial class UserControlA : UserControl
        {
            public UserControlA()
            {
                InitializeComponent();
            }
    
            #region Events deklarieren
            public static readonly RoutedEvent Erstell_LabelEvent = EventManager.RegisterRoutedEvent("Erstell_Label", RoutingStrategy.Bubble, typeof(RoutedEventHandler), typeof(UserControlA));  // öffentliches Event deklarieren
    
            public event RoutedEventHandler Erstell_Label                       // Event für BtnMake_Label angeklickt, bereitstellen
            {
                add { this.AddHandler(Erstell_LabelEvent, value); }
                remove { this.RemoveHandler(Erstell_LabelEvent, value); }
            }
    
    
            public static readonly RoutedEvent Erstell_EllipseEvent = EventManager.RegisterRoutedEvent("Erstell_Ellipse", RoutingStrategy.Bubble, typeof(RoutedEventHandler), typeof(UserControlA));  // öffentliches Event deklarieren
    
            public event RoutedEventHandler Erstell_Ellipse                     // Event für BtnMake_Ellipse angeklickt, bereitstellen
            {
                add { this.AddHandler(Erstell_EllipseEvent, value); }
                remove { this.RemoveHandler(Erstell_EllipseEvent, value); }
            }
    
    
    
            #endregion
    
            private void BtnMake_Ellipse_Click(object sender, RoutedEventArgs e)
            {
                double.TryParse(TboGroesse.Text, out double nGroesse);  // Größe der Ellipse
    
                // Eigenen EventArg-Instanzieren
                EllipseErstellenEventArgs EllipseErstellenEventArg = new EllipseErstellenEventArgs(Erstell_EllipseEvent) 
                { BrsEllipsenFarbe = BtnMake_Ellipse.Background, DblGroesse = nGroesse != 0 ? nGroesse : 30 };  // Werte für die eigenen Parameter definieren 
    
                this.RaiseEvent(EllipseErstellenEventArg);          // Ellipse-Erstellen-Event auslösen
            }
    
            private void BtnMake_Label_Click(object sender, RoutedEventArgs e)
            {
                this.RaiseEvent(new RoutedEventArgs(Erstell_LabelEvent));          // Label-Erstellen-Event auslösen
            }
    
            private void Rectangle_MouseLeftButtonDown(object sender, System.Windows.Input.MouseButtonEventArgs e)
            {
                BtnMake_Ellipse.Background = ((System.Windows.Shapes.Rectangle)sender).Fill;    // Farbe übernehmen
            }
        }
    
        // Klasse für eigene EventArgs definieren:
    
        public class EllipseErstellenEventArgs : RoutedEventArgs
        {
            // Die Basis Konstruktor(en) im Konstruktor aufrufen
            public EllipseErstellenEventArgs() : base() { }
            public EllipseErstellenEventArgs(RoutedEvent routedEvent) : base(routedEvent) { }
            public EllipseErstellenEventArgs(RoutedEvent routedEvent, object source) : base(routedEvent, source) { }
            // Zusätzliche Parameter implementieren
            public Brush BrsEllipsenFarbe { get; set; }     // Farbe der Ellipse
            public double DblGroesse { get; set; }          // Größe der Ellipse
        }
    
    }
    


    UserControlB -> Stellt Methode(n) zur Ausführung der Aufgabe(n) bereit

    <UserControl x:Class="UC_Daten_Uebernahme.UserControlB"
                 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" 
                 xmlns:local="clr-namespace:UC_Daten_Uebernahme"
                 mc:Ignorable="d" 
                 d:DesignHeight="300" d:DesignWidth="300" Background="AntiqueWhite">
        <WrapPanel  x:Name="Grid_UserControlB">
            <Label Content="UserControlB" FontWeight="Bold" />
        </WrapPanel>
    </UserControl>
    
    using System;
    using System.Windows.Controls;
    
    namespace UC_Daten_Uebernahme
    {
        /// <summary>
        /// Interaktionslogik für ucDora.xaml
        /// </summary>
        public partial class UserControlB : UserControl
        {
            public UserControlB()
            {
                InitializeComponent();
            }
    
            /// <summary>
            /// Erstellt ein Label im Grid des UserControl
            /// </summary>
            /// <param name="Text"></param>
            public void Add_Label(string myText = null)
            {
                string _Text = string.IsNullOrEmpty(myText) ? "UserControlChildren(Label): " + 
                    (Grid_UserControlB.Children.Count +1).ToString() + " Erstellt:" + DateTime.Now.ToString() : myText;
                Label myLabel = new Label
                {
                    Content = _Text
                };
                Grid_UserControlB.Children.Add(myLabel);            
            }
    
            /// <summary>
            /// Erstellt eine Ellipse im Grid des UserControl
            /// </summary>
            /// <param name="Text"></param>
            public void Add_Ellipse(System.Windows.Media.Brush myFarbe, double nGroesse)
            {
                System.Windows.Shapes.Ellipse myEllipse = new System.Windows.Shapes.Ellipse
                {
                    Fill = myFarbe, Width = nGroesse
                };
                Grid_UserControlB.Children.Add(myEllipse);
            }
    
        }
    }
    



    Donnerstag, 15. April 2021 10:40
  • Hi Bernhard,
    Fred hat die eine der vielen Lösungsmöglichkeiten gezeigt.

    Ich nutze aber lieber ein "strenges" MVVM, in welchem die einzelnen Komponenten maximal entkoppelt sind. Das bedeutet, dass weniger RoutedEvent's genutzt werden und dafür gekoppelte Eigenschaften aus dem DataContext genutzt werden, die Änderungen über INotifyPropertyChanged den anderen "Interessenten" mitteilt.


    --
    Best Regards / Viele Grüße
    Peter Fleischer (former MVP for Developer Technologies)
    Homepage, Tipps, Tricks

    Donnerstag, 15. April 2021 10:56

Alle Antworten

  • Hi Bernhard,
    du solltest dich von "übergeben" verabschieden und überall auf "holen" umstellen. D.h., jede Komponente holt sich das, was es benötigt (anzeigen , verarbeiten will). Damit eine Komponente auch weiß, dass es etwas zu holen gibt, bietet das Framework INotifyPropertyChanged. Damit kann ein Ereignis ausgelöst werden, welches dem "Abonnenten" mitteilt, dass etwas verändert (ein Wert einer Eigenschaft) wurde. Im Ereignis kann auch noch der Name der Eigenschaft mitgeteilt werden, deren Wert verändert wurde. Konkret bedeutet dass, dass es ein Objekt mit Eigenschaften in der Anwendung gibt, die alle Tabitems nutzen können. Die TabItems können dann selbst das PropertyChanged-Ereignis "abbonnieren" oder auch die Eigenschaften in der Oberfläche binden, so dass sich Änderungen dann sofort auf die Anzeige auswirken. Am einfachsten funktioniert diese Technologie mit dem MVVM Entwurfsmuster.


    --
    Best Regards / Viele Grüße
    Peter Fleischer (former MVP for Developer Technologies)
    Homepage, Tipps, Tricks

    Montag, 12. April 2021 11:16
  • Hallo Bernhard!

    Wie immer hat Peter natürlich grundsätzlich recht. Der heilige Gral in WPF ist MVVM. Damit musst du dich auseinandersetzen, wenn du effektiv in WPF weiter gehen möchtest.

    Für dein erstes Verständnis möchte ich dir aber auch noch einen Lösungsweg zeigen.

    Das Prinzip beruht auf folgender Vorgehensweise:

    1. In dem UserControl in dem du etwas auslösen möchtest, eigentlich egal was (in deinem Beispiel ein Objekt in einem anderen Usercontrol erstellen) (=UserControlA), musst du ein Event implementieren, dass ausgelöst wird, wenn du /der Benutzer es möchte. (Ich habe einfach eine Schaltfläche gewählt.)

    2. In dem UserControl in dem du eine Aktion ausführen möchtest (=UserControlB), musst du eine Methode, die diese Aktion ausführt, implementieren.

    3. Auf dem Window auf dem die Instanzen der UserControl sind (= GUI) musst du  

    das Event, das im UserControlA ausgelöst wird, abonnieren und in dessen Event-Behandlungsroutine die Aktionsausführungs-Methode von UserControlB aufrufen.

    Kurz: UserControlA feuert ein Event und UserControlB führt die gewünschte Aktion aus, da es das Event abonniert.

    Durch definieren von eigenen EventArgumenten kannst du auch beliebige Parameter mit übergeben. Ich habe das im Beispiel bei der Erstellung der Ellipsen mal demonstriert.

    GUI

    <Window x:Class="UC_Daten_Uebernahme.MainWindow"
            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:local="clr-namespace:UC_Daten_Uebernahme"
            mc:Ignorable="d"
            Title="MainWindow" Height="350" Width="525">
        <Grid>
            <Grid.RowDefinitions>
                <RowDefinition/>
                <RowDefinition/>
            </Grid.RowDefinitions>
            <local:UserControlA x:Name="UserControlA" Margin="10"
                           Erstell_Label="UsercontrolB_Erstell_Label" 
                           Erstell_Ellipse="UsercontrolB_Erstell_Ellipse"/>
            <local:UserControlB Grid.Row="2" x:Name="UserControlB" Margin="10"/>
        </Grid>
    </Window>
    
    using System.Windows;
    
    namespace UC_Daten_Uebernahme
    {
        /// <summary>
        /// Interaktionslogik für MainWindow.xaml
        /// </summary>
        public partial class MainWindow : Window
        {
            public MainWindow()
            {
                InitializeComponent();
            }
    
            private void UsercontrolB_Erstell_Label(object sender, RoutedEventArgs e)
            {
                UserControlB.Add_Label();        // Eine Methode ausführen, die durch ein Event ausgelöst wurde. 
            }
    
            private void UsercontrolB_Erstell_Ellipse(object sender, RoutedEventArgs e)
            {
                EllipseErstellenEventArgs ellipseErstellenEventArgs = (EllipseErstellenEventArgs)e;     // Standard-EventArgs in EllipseErstellenEventArgs konvertieren, um auf die zusätzlich definierten Eigenschaften zugreifen zu können.
    
                UserControlB.Add_Ellipse(ellipseErstellenEventArgs.BrsEllipsenFarbe, ellipseErstellenEventArgs.DblGroesse);
            }
        }
    }
    


    UserControl's

    (UserControlA) -> Löst Event aus

    <UserControl x:Class="UC_Daten_Uebernahme.UserControlA"
                 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" 
                 xmlns:local="clr-namespace:UC_Daten_Uebernahme"
                 mc:Ignorable="d" 
                 d:DesignHeight="300" d:DesignWidth="300" Background="LightGray">
        <Grid>
            <Label Content="UserControlA" FontWeight="Bold" />
            <StackPanel VerticalAlignment="Center" >
                <Button x:Name="BtnMake_Label" Content="Erstelle Label" Click="BtnMake_Label_Click" Margin="10" />
                <DockPanel>
                    <Rectangle DockPanel.Dock="Right" MinWidth="20" MinHeight="20" Fill="Red" VerticalAlignment="Center" Margin="0,0,3,0" MouseLeftButtonDown="Rectangle_MouseLeftButtonDown"/>
                    <Rectangle DockPanel.Dock="Right" MinWidth="20" MinHeight="20" Fill="Green" VerticalAlignment="Center" Margin="0,0,3,0" MouseLeftButtonDown="Rectangle_MouseLeftButtonDown"/>
                    <Rectangle DockPanel.Dock="Right" MinWidth="20" MinHeight="20" Fill="Yellow" VerticalAlignment="Center" Margin="0,0,3,0" MouseLeftButtonDown="Rectangle_MouseLeftButtonDown"/>
                    <TextBox DockPanel.Dock="Right" Text="30" MinHeight="20" VerticalAlignment="Center" x:Name="TboGroesse" Margin="0,0,5,0" />
                    <Button x:Name="BtnMake_Ellipse" Content="Erstelle Ellipse" Click="BtnMake_Ellipse_Click" Margin="10,10,5,10" />
                </DockPanel>
            </StackPanel>
        </Grid>
    </UserControl>
    
    using System.Windows;
    using System.Windows.Controls;
    using System.Windows.Media;
    
    namespace UC_Daten_Uebernahme
    {
        /// <summary>
        /// Interaktionslogik für ucBerta.xaml
        /// </summary>
        public partial class UserControlA : UserControl
        {
            public UserControlA()
            {
                InitializeComponent();
            }
    
            #region Events deklarieren
            public static readonly RoutedEvent Erstell_LabelEvent = EventManager.RegisterRoutedEvent("Erstell_Label", RoutingStrategy.Bubble, typeof(RoutedEventHandler), typeof(UserControlA));  // öffentliches Event deklarieren
    
            public event RoutedEventHandler Erstell_Label                       // Event für BtnMake_Label angeklickt, bereitstellen
            {
                add { this.AddHandler(Erstell_LabelEvent, value); }
                remove { this.RemoveHandler(Erstell_LabelEvent, value); }
            }
    
    
            public static readonly RoutedEvent Erstell_EllipseEvent = EventManager.RegisterRoutedEvent("Erstell_Ellipse", RoutingStrategy.Bubble, typeof(RoutedEventHandler), typeof(UserControlA));  // öffentliches Event deklarieren
    
            public event RoutedEventHandler Erstell_Ellipse                     // Event für BtnMake_Ellipse angeklickt, bereitstellen
            {
                add { this.AddHandler(Erstell_EllipseEvent, value); }
                remove { this.RemoveHandler(Erstell_EllipseEvent, value); }
            }
    
    
    
            #endregion
    
            private void BtnMake_Ellipse_Click(object sender, RoutedEventArgs e)
            {
                double.TryParse(TboGroesse.Text, out double nGroesse);  // Größe der Ellipse
    
                // Eigenen EventArg-Instanzieren
                EllipseErstellenEventArgs EllipseErstellenEventArg = new EllipseErstellenEventArgs(Erstell_EllipseEvent) 
                { BrsEllipsenFarbe = BtnMake_Ellipse.Background, DblGroesse = nGroesse != 0 ? nGroesse : 30 };  // Werte für die eigenen Parameter definieren 
    
                this.RaiseEvent(EllipseErstellenEventArg);          // Ellipse-Erstellen-Event auslösen
            }
    
            private void BtnMake_Label_Click(object sender, RoutedEventArgs e)
            {
                this.RaiseEvent(new RoutedEventArgs(Erstell_LabelEvent));          // Label-Erstellen-Event auslösen
            }
    
            private void Rectangle_MouseLeftButtonDown(object sender, System.Windows.Input.MouseButtonEventArgs e)
            {
                BtnMake_Ellipse.Background = ((System.Windows.Shapes.Rectangle)sender).Fill;    // Farbe übernehmen
            }
        }
    
        // Klasse für eigene EventArgs definieren:
    
        public class EllipseErstellenEventArgs : RoutedEventArgs
        {
            // Die Basis Konstruktor(en) im Konstruktor aufrufen
            public EllipseErstellenEventArgs() : base() { }
            public EllipseErstellenEventArgs(RoutedEvent routedEvent) : base(routedEvent) { }
            public EllipseErstellenEventArgs(RoutedEvent routedEvent, object source) : base(routedEvent, source) { }
            // Zusätzliche Parameter implementieren
            public Brush BrsEllipsenFarbe { get; set; }     // Farbe der Ellipse
            public double DblGroesse { get; set; }          // Größe der Ellipse
        }
    
    }
    


    UserControlB -> Stellt Methode(n) zur Ausführung der Aufgabe(n) bereit

    <UserControl x:Class="UC_Daten_Uebernahme.UserControlB"
                 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" 
                 xmlns:local="clr-namespace:UC_Daten_Uebernahme"
                 mc:Ignorable="d" 
                 d:DesignHeight="300" d:DesignWidth="300" Background="AntiqueWhite">
        <WrapPanel  x:Name="Grid_UserControlB">
            <Label Content="UserControlB" FontWeight="Bold" />
        </WrapPanel>
    </UserControl>
    
    using System;
    using System.Windows.Controls;
    
    namespace UC_Daten_Uebernahme
    {
        /// <summary>
        /// Interaktionslogik für ucDora.xaml
        /// </summary>
        public partial class UserControlB : UserControl
        {
            public UserControlB()
            {
                InitializeComponent();
            }
    
            /// <summary>
            /// Erstellt ein Label im Grid des UserControl
            /// </summary>
            /// <param name="Text"></param>
            public void Add_Label(string myText = null)
            {
                string _Text = string.IsNullOrEmpty(myText) ? "UserControlChildren(Label): " + 
                    (Grid_UserControlB.Children.Count +1).ToString() + " Erstellt:" + DateTime.Now.ToString() : myText;
                Label myLabel = new Label
                {
                    Content = _Text
                };
                Grid_UserControlB.Children.Add(myLabel);            
            }
    
            /// <summary>
            /// Erstellt eine Ellipse im Grid des UserControl
            /// </summary>
            /// <param name="Text"></param>
            public void Add_Ellipse(System.Windows.Media.Brush myFarbe, double nGroesse)
            {
                System.Windows.Shapes.Ellipse myEllipse = new System.Windows.Shapes.Ellipse
                {
                    Fill = myFarbe, Width = nGroesse
                };
                Grid_UserControlB.Children.Add(myEllipse);
            }
    
        }
    }
    



    Donnerstag, 15. April 2021 10:40
  • Hi Bernhard,
    Fred hat die eine der vielen Lösungsmöglichkeiten gezeigt.

    Ich nutze aber lieber ein "strenges" MVVM, in welchem die einzelnen Komponenten maximal entkoppelt sind. Das bedeutet, dass weniger RoutedEvent's genutzt werden und dafür gekoppelte Eigenschaften aus dem DataContext genutzt werden, die Änderungen über INotifyPropertyChanged den anderen "Interessenten" mitteilt.


    --
    Best Regards / Viele Grüße
    Peter Fleischer (former MVP for Developer Technologies)
    Homepage, Tipps, Tricks

    Donnerstag, 15. April 2021 10:56