Code auslagern (in Klassen?) - Verbindung zur MainWindow klappt nicht (VB.NET Umsteiger)

Guten Abend,

Ich habe eine Frage, muss mich aber ersteinmal kurz erklären...
Ich habe 20Jahre lang VB bzw. VB.NET Programmiert und versuche mich seit heute an C# mit WPF Elementen.
Also bitte etwas Rücksicht 🙂

Folgendes Problem / Vielleicht auch nur ein Verständnissproblem:
Ist jetzt nur ein Beispiel, was nicht viel Sinn machen wird, aber mein Problem veranschaulicht

Ich habe ein MainWnidow.xaml

namespace Test
{
    /// <summary>
    /// Interaction logic for MainWindow.xaml
    /// </summary>
    public partial class MainWindow : Window
    {
        public MainWindow()
        {
            InitializeComponent();
            
        }
        public void Window_Loaded(object sender, RoutedEventArgs e)
        {
            //Programmstart
           start.starcode();
        }
       
    }
}

Ich möchte gern (wie in VB) den Code "auslagern".
In VB warne das Module.

Ich habe mir einen Ordner "src" erstellt, wo ich die "start.cs" reingelegt habe:

namespace Test.src
{
    public class start
    {
        public static void startcode()
        {
            //starte Programm
           
        }

    }
}

In startcode() möchte ich jetzt eigentlich gern schreiben:

MainWindow.label01.text = "Hallo";

Geht aber nicht.
Es kommt die Meldung: "MainWindow enthält keine Definition von Label1."
Das habe ich aber erstellt und auch so benannt.

Wie gesagt, dass Beispiel macht in Summe nicht viel Sinn, aber erklärt mein Problem ganz gut.

In VB.Net hatte ich immer Codeblöcke, die funktioniert haben in Module ausgelagert und abgerufen. Einfach, damit ich mir die nicht jedes mal beim Scrollen neu ansehen muss, weil diese ja funktionieren.

Entweder habe ich ein Verständnissproblem und die Klassen in C# sind die falsche Wahl, oder mir fehlt etwas was ich bei google nicht finde.

Hallo
Ich verstehe nicht, was du damit erreichen willst, aber da es sich hierbei um WPF handelt, solltest du dir unbedingt mal das ansehen: [Artikel] MVVM und DataBinding

Das ist das Problem von VB(6/net), es ist vieles vereinfacht, was dazu führt das die Leute die es benutzen die Grundlagen nicht erlernen müssen.

Das ist bei C# anders. Du musst die Grundlagen der OOP und danach die Grundlagen der Technologie die du benutzen willst erlernen.

In Deinem Fall,
Rheinwerk Computing :: Objektorientierte Programmierung - Das umfassende Handbuch
[FAQ] Wie finde ich den Einstieg in C#?

Und direkt in WPF einsteigen macht es nicht einfacher, da du hier noch viel mehr lernen musst, wie z.b. MVVM, Pattern, Dependency injection und einiges mehr.
[Artikel] MVVM und DataBinding

Hallo
Ich verstehe nicht, was du damit erreichen willst,....[/url]

Naja, mal angenommen ich lese beim Programmstart eine Datei ein und bringe die Daten in ein Datagrid(view).
Das brauche ich einmal und will/muss es nicht immer sehen.
Deshalb habe ich solche fertigen Codes immer in Module gelegt und innerhalb der Form abgerufen.

WPF habe ich eigentlich nur genommen, weil es alles etwas schöner aussieht...
Ich dachte, wenn dann gleich richtig.
So wie eure Antworten Aussehen, sollte ich erstmal ohne WPF losstarten.

Aber Danke für die Links... Ich schau mir das gleich mal an.

Habt ihr dennoch eine Antwort, ob ich auf dem Holzweg bin?

In WPF könnte dies so aussehen:
Pakete CommunityToolkit.Mvvm installieren für das RelayCommand.
Microsoft.Xaml.Behaviors.Wpf installieren für die Eventverarbeitung

Ein MainWindow erstellen, ViewModel (vm) und Behaviors (behav) definieren.
Datenbindung für das Window loaded event und den Text für das Label erstellen.

<Window x:Class="MyCSharp125145.Views.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:behav="http://schemas.microsoft.com/xaml/behaviors"
        xmlns:vm="clr-namespace:MyCSharp125145.ViewModels"
        mc:Ignorable="d"
        Title="MainWindow" 
        Height="150" 
        Width="250">

    <Window.DataContext>
        <vm:MainWindowViewModel />
    </Window.DataContext>
    
    <behav:Interaction.Triggers>
        <behav:EventTrigger EventName="Loaded">
            <behav:InvokeCommandAction Command="{Binding WindowLoadedEventCommand}" />
        </behav:EventTrigger>
    </behav:Interaction.Triggers>

    
    <Grid>
        <Label x:Name="welcomeLabel"
               Content="{Binding WelcomeLabelText}" />
    </Grid>
</Window>

Wir brauchen auch ein ViewModel, das die Logik des MainWindows enthält. Dieses ist abgeleitet von ViewModelBase

public class MainWindowViewModel : ViewModelBase
    {
		private string welcomeLabelText;

		public string WelcomeLabelText
        {
			get { return welcomeLabelText; }
			set
			{
				if (welcomeLabelText != value)
				{
                    welcomeLabelText = value;
					OnPropertyChanged();
				}
			}
		}

		public ICommand WindowLoadedEventCommand { get; private set; }

		public MainWindowViewModel()
		{
			WindowLoadedEventCommand = new RelayCommand(SetLabelText);
		}

		private void SetLabelText()
		{
            WelcomeLabelText = "Hallo";
        }
	}

    public abstract class ViewModelBase : INotifyPropertyChanged
    {
        public event PropertyChangedEventHandler PropertyChanged;

        protected virtual void OnPropertyChanged([CallerMemberName] string propertyName = null)
        {
            PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(propertyName));
        }
    }

Alter 😲

Danke für die Antwort.... Da fliegt einem ja die Rübe weg.
Ich glaube ich fange erstmal vorsichtig mit C# (Klassich) an.

Deine Ideen sehen ganz nach diesem Problem aus: [FAQ] Kommunikation von 2 Forms
Das ist unabhängig von der Oberfläche. Egal ob WPF oder Winforms. Schau dir unbedingt mal OOP an.

Klassen in C# sind die falsche Wahl...OOP

Generell: der C#-Compiler erzwingt die Verwendung von (wenigstens einer) Klasse(n) um Methoden/Variablen/... dort zu definieren. Zwecks OOP (neben dem Openbook) siehe diesen
Twitter Thread
Der längerfristige Sinn dieser (strenggenommen nur empfohlenen) menschlichen Verhaltensweisen wird klar, wenn man die Software (an zentraler Stelle) häufig(er) (oder leicht(er)) ändern/erweitern/nutzen/... will: Entwurfsmuster, Schichtentrennung, SOLID-Prinzipien, OOA, OOD, TDD, K.I.S.S., Namensgebung, ...

Hallo Sisco86

MainWindow.label01.text = "Hallo";

Das was du da machst, ist auch in VB keine gute Idee. Die Geschäfts-Logik sollte keine Abhängigkeit auf die UI haben:

[Artikel] Drei-Schichten-Architektur

Gruß
Alf 🙂