Wie schon weiter oben erwähnt sollte das hier funktionieren.

        private void Anzeige(int screenIdx, int xPos, int yPos, int xDim, int yDim)
        {
            Screen monitor = Screen.AllScreens[screenIdx];
            Rectangle screenArea = monitor.WorkingArea;
            f3.StartPosition = FormStartPosition.Manual;
            f3.BackColor = Color.RebeccaPurple;
            f3.Size = new Size(xDim, yDim);
            f3.Location = new Point(screenArea.X + xPos, screenArea.Y + yPos);
        }

VS sagt Dir ziemlich genau, wo der Fehler liegt.

namespace erstes
{
    internal class Program
    {
        static void Main(string[] args)
        {
            Funktion.Rechner(10, 20);
            Console.WriteLine("1. Seite");
        }
    }
}

Zweite Datei Funktion.cs

namespace erstes
{
    public static class Funktion
    {
        public static void Rechner(int numba, int numbb)
        {
            int a = numba;
            int b = numbb;

            int Result = numba + numbb;
            Console.WriteLine("Ergebns ist " + Result);
        }
    }
}

Das Projekt habe ich aufgegeben, da ich an der Stelle nicht weitergekommen bin.

Hatte auch nur den Zweck etwas rumzuprobieren und mit Blazor vertraut zu werden.

Zitat von Mersaia

die if Anweisung mit der Überprüfung auf Lange, Hoehe, Breite auf 0 um eventuelle Fehlereingaben mit einer Eingabe 0 in Hohe Länge Breite abzufangen? Theoretisch würde ja bspw. nur Länge abfragen auch gehen weil der Anwender bei der Eingabe keine 0 eingeben soll? auch wenn es unsauber ist. es geht nur um das Verständnis.

Ja, die Überprüfung sollte idealerweise ODER-Verknüpft sein. Und das Kriterium sollte nicht  == 0 sein sondern <= 0. Dass der Anwender keine 0 eingeben soll, kann ich nicht erkennen.

Ist es das, was Du willst?

                    case '1':
                        Console.WriteLine("Neue Kiste erstellen");
                        for (int index = 0; index < lagerraum.Length; index++)
                        {
                            // Prüfe, ob die Kiste definiert ist
                            if (lagerraum[index].Laenge == 0 && lagerraum[index].Breite == 0 && lagerraum[index].Hoehe == 0)
                            {
                                // Lese bei undefinierter Kiste die Werte ein und verlasse die Schleife.
                                lagerraum[index] = Einlesen(index + 1);
                                break;
                            }
                        }
                        break;

Ich habe das KI-Modell codegemma befragt und folgenden Snippet als Antwort erhalten:

// Erhalten Sie die letzten beschriebenen Zeile in der angegebenen Spalte
int lastRow = worksheet.Cells[worksheet.Rows.Count, columnNumber].End(Excel.XlDirection.xlUp).Row;

Eine Möglichkeit ist hier beschrieben: https://learn.microsoft.com/de-de/dotnet/desktop/winforms/migration/?view=netdesktop-8.0

Was sagt denn eigentlich Dein Ausbilder? Kannst Du den nicht fragen?

Datei Vendingmachine.cs

    public class Vendingmachine
    {
        #region Fields
        /// <summary>
        /// Die Getränkefächer
        /// </summary>
        private readonly List<Slot> slots;
        #endregion

        #region Constructors
        /// <summary>
        /// Erstellt eine neue Instanz eines Getränkeautomaten
        /// </summary>
        public Vendingmachine()
        {
            slots = [];
        }
        #endregion

        #region Methods
        /// <summary>
        /// Auffüllen des Getränkeautomaten
        /// </summary>
        public void Fill()
        {
            slots.Add(new Slot(new Beverage("Helles Bier", 2.60m), 20, 5));
            slots.Add(new Slot(new Beverage("Pils", 3.00m), 25, 5));
            slots.Add(new Slot(new Beverage("Schwarzbier", 2.70m), 20, 5));
            slots.Add(new Slot(new Beverage("Weizen", 3.20m), 20, 5));
            slots.Add(new Slot(new Beverage("Lagerbier", 2.80m), 20, 5));
            slots.Add(new Slot(new Beverage("Kellerbier", 2.60m), 20, 5));
            slots.Add(new Slot(new Beverage("Bockbier", 3.40m), 20, 5));
            slots.Add(new Slot(new Beverage("Zwickl", 2.90m), 20, 5));

            RegisterSlots();
        }

        /// <summary>
        /// Gebe den Begrüßungsbildschirm aus
        /// </summary>
        public void Greet()
        {
            Console.WriteLine("###############################");
            Console.WriteLine("#                             #");
            Console.WriteLine("#       Hello Customer!       #");
            Console.WriteLine("#                             #");
            Console.WriteLine("###############################");
            Console.WriteLine("#                             #");
            Console.WriteLine("# {0,3} {1,-13} {2,6} {3,2} #", "Id", "Name", "Price", "No");
            Console.WriteLine("#                             #");
            PrintSlotInfo();
        }

        /// <summary>
        /// Gebe die Getränkefächer am Begrüßungsbildschirm aus
        /// </summary>
        private void PrintSlotInfo()
        {
            for (int i = 0; i < slots.Count; i++)
            {
                Console.WriteLine("# {0,2}. {1,-12} {2,6}€ {3,2} #", i + 1, slots[i].Beverage.Name, slots[i].Beverage.Price, slots[i].CurrentLevel);
            }
        }

        /// <summary>
        /// Die Getränkefachanwahl
        /// </summary>
        /// <param name="slotnumber">Die Getränkefachnummer</param>
        public void Select(int slotnumber)
        {
            if (slotnumber > 0 && slotnumber <= slots.Count)
            {
                int slotIndex = slotnumber - 1;
                slots[slotIndex].Select();
            }
            else if (slotnumber == 0)
            {
                Checkout();
            }
        }

        /// <summary>
        /// Kein weiteres Getränk angewählt
        /// deshalb Ausgabe der gewählen Getränke mit 
        /// </summary>
        private void Checkout()
        {
            decimal total = 0.0m;
            string message = string.Empty;
            Print(string.Empty);
            Print("Checkout:");

            foreach (Slot slot in slots)
            {
                total += slot.Selected * slot.Beverage.Price;
                message = slot.GetTotal();
                if (!string.IsNullOrEmpty(message))
                {
                    Print(message);
                }
                slot.ResetSelection();
            }

            Print(new string('=', 37));
            Print(string.Format("{0,36}€", total));

            Print(string.Empty);
            Print(string.Empty);
            Greet();
        }

        /// <summary>
        /// Konsolenausgabe
        /// </summary>
        /// <param name="message">Die Nachricht die auf der Konsole ausgegeben werden soll</param>
        private void Print(string message)
        {
            Console.WriteLine(message);
        }

        /// <summary>
        /// Abonniere die Getränkefachereignisse
        /// </summary>
        private void RegisterSlots()
        {
            RegisterSlotsThreshold();
            RegisterSlotsEmpty();
        }

        /// <summary>
        /// Aboniere von jedem Getränkefach das Schwellwertereignis
        /// </summary>
        private void RegisterSlotsThreshold()
        {
            foreach (Slot slot in slots)
            {
                slot.BelowThreshold += OnSlotIsBelowThreshold;
            }
        }

        /// <summary>
        /// Aboniere von jedem Getränkefach das Fach leer Ereignis 
        /// </summary>
        private void RegisterSlotsEmpty()
        {
            foreach (Slot slot in slots)
            {
                slot.Empty += OnSlotIsEmpty;
            }
        }

        /// <summary>
        /// Gebe einen Alam aus, wenn das Getränkefach leer ist
        /// </summary>
        /// <param name="sender">Das Getränkefach</param>
        /// <param name="e">Nicht in Verwendung</param>
        private void OnSlotIsEmpty(object? sender, EventArgs e)
        {
            if (sender is Slot slot)
            {
                Console.WriteLine($"ALERT: The beer {slot.Beverage.Name} is empty!");
            }
        }

        /// <summary>
        /// Gebe einen Alam aus, wenn der Schwellwert unterschritten wird
        /// </summary>
        /// <param name="sender">Das Getränkefach</param>
        /// <param name="e">Nicht in Verwendung</param>
        private void OnSlotIsBelowThreshold(object? sender, EventArgs e)
        {
            if (sender is Slot slot)
            {
                Console.WriteLine($"ALERT: The beer {slot.Beverage.Name} is running out!");
            }
        }
        #endregion
    }

Datei Program.cs

    internal class Program
    {
        static void Main()
        {
            Vendingmachine vendingmachine = new();
            vendingmachine.Fill();
            vendingmachine.Greet();
            ConsoleKeyInfo pressedKey;

            do
            {
                pressedKey = Console.ReadKey();
                if (int.TryParse(pressedKey.KeyChar.ToString(), out int slotNumber))
                {
                    vendingmachine.Select(slotNumber);
                }

            } while (pressedKey.Key != ConsoleKey.X);
        }
    }

Aufgabe für Dich: Es werden bei der Konsolenausgabe statt dem € Zeichen nur ? angezeigt. Warum ist das so und wie lässt sich das beheben? Eine zusätzliche Codezeile ist dazu nötig!

Zweite Aufgabe für Dich: Die Konsolenausgaben vereinheitlichen.

Okay! Muss das auf zwei Posts verteilen, da mehr als 8000 Zeichen!

Datei Beverage.cs

    public class Beverage
    {
        /// <summary>
        /// Der Getränkename
        /// </summary>
        public string? Name { get; }

        /// <summary>
        /// Der Getränkepreis
        /// </summary>
        public decimal Price { get; }

        /// <summary>
        /// Erstelle eine neue Instanz einer Getränkesorte
        /// </summary>
        /// <param name="name">Der Getränkename</param>
        /// <param name="price">Der Getränkepreis</param>
        public Beverage(string name, decimal price)
        {
            Name = name;
            Price = price;
        }
    }

Datei Slot.cs

    public class Slot
    {
        #region Properties
        /// <summary>
        /// Die Getränkesorte
        /// </summary>
        public Beverage Beverage { get; set; }

        /// <summary>
        /// Die Kapazität des Getränkefachs
        /// </summary>
        public int Capacity { get; set; }

        /// <summary>
        /// Der aktuelle Füllstand des Getränkefachs
        /// </summary>
        public int CurrentLevel { get; private set; }

        /// <summary>
        /// Der Schwellwert des Getränkefachs bei dessen Unterschreitung ein Alarm ausgelöst wird
        /// </summary>
        public int Threshold { get; set; }

        /// <summary>
        /// Die Anzahl der Getränke
        /// </summary>
        public int Selected { get; private set; }
        #endregion

        #region Events
        /// <summary>
        /// Das Ereignis welches ausgelöst wird wenn der Schwellwert unterschritten wird
        /// </summary>
        public event EventHandler? BelowThreshold;

        /// <summary>
        /// Das Ereignis welches ausgelöst wird wenn das Getränkefach leer ist
        /// </summary>
        public event EventHandler? Empty;
        #endregion

        #region Constructors
        /// <summary>
        /// Erstelle eine neue Instanz eines Getränkefaches
        /// </summary>
        /// <param name="beverage">Die Getränkesorte</param>
        /// <param name="capacity">Die Kapazität des Getränkefaches</param>
        /// <param name="threshold">Der Schwellwert</param>
        public Slot(Beverage beverage, int capacity, int threshold)
        {
            Beverage = beverage;
            Capacity = capacity;
            Threshold = threshold;
            CurrentLevel = Capacity;
            Selected = 0;
        }
        #endregion

        #region Methods
        /// <summary>
        /// Die Getränkewahl
        /// </summary>
        public void Select()
        {
            if (CurrentLevel > 0)
            {
                Selected++;
                CurrentLevel--;
                Console.WriteLine($"You selected a {Beverage.Name} for {Beverage.Price}");
                if (CurrentLevel < Threshold)
                {
                    BelowThreshold?.Invoke(this, new EventArgs());
                }
            } 
            else if (CurrentLevel == 0)
            {
                Empty?.Invoke(this, new EventArgs());
            }
        }

        /// <summary>
        /// Setzt die Getränkewahl zurück
        /// </summary>
        public void ResetSelection()
        {
            Selected = 0;
        }

        /// <summary>
        /// Die Getränkeabwahl
        /// Nicht implementiert
        /// </summary>
        public void Unselect()
        {
            Selected--;
            CurrentLevel++;
        }

        /// <summary>
        /// Liefert den Preis von einem Getränk
        /// Nicht implementiert
        /// </summary>
        /// <returns>Der Getränkepreis</returns>
        public string GetPrice()
        {
            return $"Price for {Beverage.Name} is {Beverage.Price:C2}";
        }

        /// <summary>
        /// Liefert den Gesamtpreis von einem Getränk
        /// </summary>
        /// <returns>Der Gesamtpreis von einem Getränk</returns>
        public string GetTotal()
        {
            string message = string.Empty ;
            if (Selected > 0)
            {
                message = string.Format("{0, 2}x {1,-13} a {2,6}€ = {3,6}€", Selected, Beverage.Name, Beverage.Price, Selected * Beverage.Price);
            }
            return message ;
        }
        #endregion
    }