Willkommen auf myCSharp.de! Anmelden | kostenlos registrieren
 | Suche | FAQ

Hauptmenü
myCSharp.de
» Startseite
» Forum
» Suche
» Regeln
» Wie poste ich richtig?

Mitglieder
» Liste / Suche
» Wer ist online?

Ressourcen
» FAQ
» Artikel
» C#-Snippets
» Jobbörse
» Microsoft Docs

Team
» Kontakt
» Cookies
» Spenden
» Datenschutz
» Impressum

  • »
  • Portal
  • |
  • Mitglieder
Beiträge von Tommylik
Thema: Anzahl Checkbox checked als Wert für for Schleife
Am im Forum: Grundlagen von C#

Hallo Th69,

Vielen Dank für deine Antwort.

Zitat
Die Methode GetLocalPathConfigSettings() sieht so korrekt aus.

Ok wenigstens etwas obwohl es ja dein Verdienst ist.

Ich kapier es nicht wie ich diese 5 Methodenaufrufe aus der Methode GetLocalPathConfigSettings()

MainForm


public void GetLocalPathConfigSettings()
        {
            var settings = Settings.Default;

            settings.SetControlTexts(tbLocalAppNames, "LocalAppName");
            settings.SetControlTexts(tbSourceFilePathLocalApps, "LocalAppFilePath");
            settings.SetControlTexts(tbSetPointFileLocalApps, "SetPointLocalApp");

            settings.SetCheckBoxes(cbActivateLocalApps, "LocalAppAktiv");
            settings.SetCheckBoxes(cbActivateCode2LocalApps, "ActivateCode2LocalApp");
        }


hier in die 2 Methoden reinbringe.

Settings.cs


using System.Windows.Forms;

namespace PDE.Properties
{   
    internal sealed partial class Settings
    {   

#######################################################################  
        Ich denke hier brauche ich noch neue arrays aber ich weiß es nicht und das ist das was mich ärgert.
#######################################################################


        internal void SetControlTexts(Control[] tbLocalAppNames, string v) <-- //tbLocalAppNames muss falsch sein
        {
            ?
        }

        internal void SetCheckBoxes(CheckBox[] ?, string v)
        {
               for (int i = 0; i < ?.Length; i++)
              {
               ?[i].Checked = (bool)Settings.Default[v + (i + 1)];
               }
        }

Es tut mir Leid aber das überfordert mich doch, alles in der Mainform zu machen ist eine Sache
aber mit einer Klasse in Zusammenspiel ist zu viel für mich.

Das ihr Euch das alles merken könnt wo Ihr was braucht (referenzieren, instanziieren, ....usw.)

Da muss ich mir noch viele Beispiele im Internet anschauen. Kennst du ein Beispiel was mir helfen könnte?
Das ich es vielleicht dadurch erarbeiten kann.

Vielen Dank für Deine Hilfe und Geduld.

Grüße Tommylik

Thema: Anzahl Checkbox checked als Wert für for Schleife
Am im Forum: Grundlagen von C#

Hallo Abt,

Vielen Dank für deine Antwort.

Zitat
Das Prinzip nennt sich DRY => Don’t repeat yourself

Das kenne ich und deswegen bin ich ja dabei das mit den Schleifen zu lernen.
Ich möchte ja selber keinen Code der sich wiederholt. Nur die Umsetzung ist halt nicht so einfach.

Dann habe ich noch eine Frage. Ich kann also alles was in der Settings.cs auf 2 Methoden einkürzen.
Ist denn was ich in der MainForm gemacht habe richtig?

Oder muss das so aussehen? Mit SetControlTexts und SetCheckBoxes


public void GetLocalPathConfigSettings()
        {         
            var settings = Settings.Default;

            settings.SetControlTexts(tbLocalAppNames, "LocalAppName");
            settings.SetControlTexts(tbSourceFilePathLocalApps, "LocalAppFilePath");
            settings.SetControlTexts(tbSetPointFileLocalApps, "SetPointLocalApp");

            settings.SetCheckBoxes(cbActivateLocalApps, "LocalAppAktiv");
            settings.SetCheckBoxes(cbActivateCode2LocalApps, "ActivateCode2LocalApp");   
        }


public void SaveLocalPathConfigSettings()
        {
            var settings = Settings.Default;

            settings.SetControlTexts(tbLocalAppNames, "LocalAppName");
            settings.SetControlTexts(tbSourceFilePathLocalApps, "LocalAppFilePath");
            settings.SetControlTexts(tbSetPointFileLocalApps, "SetPointLocalApp");

            settings.SetCheckBoxes(cbActivateLocalApps, "LocalAppAktiv");
            settings.SetCheckBoxes(cbActivateCode2LocalApps, "ActivateCode2LocalApp");           

            Settings.Default.Save();
        }
Zitat
von TH69
Die Methodenparameter für die ausgelagerten Methoden dann als Control[] bzw. CheckBox[] deklarieren

Muss das Control[] sein oder Textbox[]?

Wäre es richtig, wenn ich den folgenden Code aus der Mainform in die Settings.cs übernehme?


        private TextBox[] tbLocalAppNames;
        private TextBox[] tbSourceFilePathLocalApps;
        private TextBox[] tbSetPointFileLocalApps;
        private CheckBox[] cbActivateLocalApps;
        private CheckBox[] cbActivateCode2LocalApps;

Vielen Dank nochmal für Deine Hilfe.

Grüße Tommylik

Thema: Anzahl Checkbox checked als Wert für for Schleife
Am im Forum: Grundlagen von C#

Hallo TH69,

Vielen Dank für deine Antwort und da muss ich dir gleich antworten.

Zitat
Mir scheint, du machst dir immer mehr Arbeit als nötig ist.

Das ist ja kein wunder da ich ja oft nicht weiß was ich tue.
Zitat
Du brauchst doch nicht für jedes konkrete Array eine eigene Methode (dafür sind doch die Parameter da), sondern (bisher) nur zwei verschiedene: für den Zugriff auf Text und Checked. Daher auch meine allgemeinen Namen: SetControlTexts und SetCheckBoxes.

Ok aber damit ich es besser verstehe und damit ich weiß wo ich ansetzen muss, das was ich umgesetzt habe ist falsch?
Verstehe ich dich richtig das ich die ganzen Methoden in der Settings.cs auf 2 Methoden einkürzen kann?
Ich tue mich halt schwer damit das was du mir als Hilfe zur Verfügung stellst an den richtigen stellen einzusetzen.
Zitat
Ich hoffe, ich überfordere dich nicht zu sehr, aber es freut mich, dass du meine Tipps umsetzt. ;-)

Nein, aber es ist auch nicht gerade ein Kinderspiel. Ich möchte halt nicht nicht aufgeben. Es macht mir spaß.
Aber jetzt mal die Gegenfrage wie viel Geduld hast?
Zitat
Bei deinem jetzigen Code könnte man noch mehr Code einsparen (optimieren),

Darüber sollten wir nachdenken wenn ich das Thema Klasse > Form verstanden habe.
Und so aufgebaut ist wie es sein sollte.

Vielen Dank für deine bisherige Hilfe, Mühe und Zeit.

Grüße Tommylik

Thema: Anzahl Checkbox checked als Wert für for Schleife
Am im Forum: Grundlagen von C#

Hallo TH69,

Vielen Dank für deine tolle Hilfe.

Zitat
PS: Zum Thema "Zugriff von anderer Klasse auf Window Control" kannst du dir auch mal meinen längeren Artikel Kommunikation von 2 Forms durchlesen.

Denn habe ich mir durchgelesen und deshalb denke ich das ich es nicht richtig umgesetzt habe.
Ich denke das mir der Eventhandler fehlt. Und wer weiß was sonst noch.
Was halt blöd ist, das es funktioniert trotzdem das ich es falsch umgesetzt habe.

Tut mir leid, dass es mit mir so schwierig ist.

Hier meine Umsetzung:

Settings.cs


using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows.Forms;

namespace PDE.Properties
{
    internal sealed partial class Settings
    {
        
        internal void GetLocalAppNames(TextBox[] tbLocalAppNames, string v)
        {
            for (int i = 0; i < tbLocalAppNames.Length; i++)
            {
                tbLocalAppNames[i].Text = (string)Settings.Default[v + (i + 1)];
            }

            //throw new NotImplementedException();
        }

        internal void GetSourceFilePathLocalApps(TextBox[] tbSourceFilePathLocalApps, string v)
        {
            for (int i = 0; i < tbSourceFilePathLocalApps.Length; i++)
            {
                tbSourceFilePathLocalApps[i].Text = (string)Settings.Default[v + (i + 1)];
            }

            //throw new NotImplementedException();
        }

        internal void GetSetPointFileLocalApps(TextBox[] tbSetPointFileLocalApps, string v)
        {
            for (int i = 0; i < tbSetPointFileLocalApps.Length; i++)
            {
                tbSetPointFileLocalApps[i].Text = (string)Settings.Default[v + (i + 1)];
            }

            //throw new NotImplementedException();
        }

        internal void GetActivateLocalApps(CheckBox[] cbActivateLocalApps, string v)
        {
            for (int i = 0; i < cbActivateLocalApps.Length; i++)
            {
                cbActivateLocalApps[i].Checked = (bool)Settings.Default[v + (i + 1)];
            }

            //throw new NotImplementedException();
        }

        internal void GetActivateCode2LocalApps(CheckBox[] cbActivateCode2LocalApps, string v)
        {
            for (int i = 0; i < cbActivateCode2LocalApps.Length; i++)
            {
                cbActivateCode2LocalApps[i].Checked = (bool)Settings.Default[v + (i + 1)];
            }

            //throw new NotImplementedException();
        }       

        internal void SaveLocalAppNames(TextBox[] tbLocalAppNames, string v)
        {
            for (int i = 0; i < tbLocalAppNames.Length; i++)
            {
                Settings.Default[v + (i + 1)] = tbLocalAppNames[i].Text;
            }
            //throw new NotImplementedException();
        }

        internal void SaveSourceFilePathLocalApps(TextBox[] tbSourceFilePathLocalApps, string v)
        {
            for (int i = 0; i < tbSourceFilePathLocalApps.Length; i++)
            {
                Settings.Default[v + (i + 1)] = tbSourceFilePathLocalApps[i].Text;
            }
            //throw new NotImplementedException();
        }

        internal void SaveSetPointFileLocalApps(TextBox[] tbSetPointFileLocalApps, string v)
        {
            for (int i = 0; i < tbSetPointFileLocalApps.Length; i++)
            {
                Settings.Default[v + (i + 1)] = tbSetPointFileLocalApps[i].Text;
            }
            //throw new NotImplementedException();
        }

        internal void SaveActivateLocalApps(CheckBox[] cbActivateLocalApps, string v)
        {
            for (int i = 0; i < cbActivateLocalApps.Length; i++)
            {
                Settings.Default[v + (i + 1)] = cbActivateLocalApps[i].Checked;
            }
            //throw new NotImplementedException();
        }

        internal void SaveActivateCode2LocalApps(CheckBox[] cbActivateCode2LocalApps, string v)
        {
            for (int i = 0; i < cbActivateCode2LocalApps.Length; i++)
            {
                Settings.Default[v + (i + 1)] = cbActivateCode2LocalApps[i].Checked;
            }
            //throw new NotImplementedException();
        }      
    }
}

MainForm.cs



using PDE.Properties;


namespace PDE
{
    public partial class MainForm : Form
    {
        public void GetLocalPathConfigSettings()
        {
            this.txtChooseTargetPath.Text = Settings.Default.TargetPath;

            var settings = Settings.Default;

            settings.GetLocalAppNames(tbLocalAppNames, "LocalAppName");
            settings.GetSourceFilePathLocalApps(tbSourceFilePathLocalApps, "LocalAppFilePath");
            settings.GetSetPointFileLocalApps(tbSetPointFileLocalApps, "SetPointLocalApp");
            settings.GetActivateLocalApps(cbActivateLocalApps, "LocalAppAktiv");
            settings.GetActivateCode2LocalApps(cbActivateCode2LocalApps, "ActivateCode2LocalApp");          
     }


public void SaveLocalPathConfigSettings()
        {
            var settings = Settings.Default;

            settings.SaveLocalAppNames(tbLocalAppNames, "LocalAppName");
            settings.SaveSourceFilePathLocalApps(tbSourceFilePathLocalApps, "LocalAppFilePath");
            settings.SaveSetPointFileLocalApps(tbSetPointFileLocalApps, "SetPointLocalApp");
            settings.SaveActivateLocalApps(cbActivateLocalApps, "LocalAppAktiv");
            settings.SaveActivateCode2LocalApps(cbActivateCode2LocalApps, "ActivateCode2LocalApp");

            Settings.Default.TargetPath = this.txtChooseTargetPath.Text;          

            Settings.Default.Save();
        }

Zitat
PS: Zum Thema "Zugriff von anderer Klasse auf Window Control" kannst du dir auch mal meinen längeren Artikel Kommunikation von 2 Forms durchlesen.
Ich will mal dieses Beispiel ausprobieren zum lernen:
Zitat
Für das Beispiel, daß eine SubForm den Label-Text der MainForm aktualisieren soll (z.B. um einen Status anzuzeigen) sieht der Code dann so aus:


class SubForm : Form
{
  // ...

  public class TextEventArgs : EventArgs
  {
    public TextEventArgs(string text)
    {
      Text = text; // Eigenschaft setzen
    }

    public string Text { get; set; } // Text als Eigenschaft definieren
  }

  public event EventHandler<TextEventArgs> UpdateText; // Ereignis deklarieren

  void button_Click(object sender, EventArgs e)
  {
    // ...
    
    OnUpdateText(new TextEventArgs("Test")); // Ereignis-Methode aufrufen
  }

  protected virtual void OnUpdateText(TextEventArgs e)
  {
    EventHandler<TextEventArgs> ev = UpdateText;
    if (ev != null)
      ev(this, e); // abonnierte Ereignismethode(n) aufrufen
  }
}

Zitat
Und nun muß im MainForm dann noch dieses Ereignis abonniert (zugewiesen) werden:


class MainForm : Form
{
  void button_Click(object sender, EventArgs e)
  {
    SubForm subForm = new SubForm();
    subForm.UpdateText += UpdateLabelText; // Ereignis abonnieren
    subForm.ShowDialog(this);
  }

  void UpdateLabelText(object sender, SubForm.TextEventArgs e)
  {
    labelText.Text = e.Text; // Zugriff auf Eigenschaft des Ereignisses
  }
}

Ich muss es doch schaffen diesen aha-Efekt zu bekommen.

Vielen Dank nochmal für deine besondere Hilfe.

Grüße Tommylik

Thema: Anzahl Checkbox checked als Wert für for Schleife
Am im Forum: Grundlagen von C#

Hallo an alle,

Vielen Dank für Eure Antworten.

@TH69

Vielen Dank für die Code Beispiele. Dadurch sind nochmal ein haufen Codezeilen rausgeflogen.

Zitat
wenn du dir die Settings.Designer.cs mal (mit einem Texteditor) anschaust, dann siehst du, daß intern einfach nur der Index-Operator Item[String] der Basisklasse ApplicationSettingsBase benutzt wird, d.h. diesen kannst du also einfach selber nutzen, z.B.

Die Items sind die "propertyName" die ich in der Settings.settings angelegt habe.

Ich habe jetzt für alle eine Schleife angelegt.


public void GetLocalPathConfigSettings()
        {
            this.txtChooseTargetPath.Text = Properties.Settings.Default.TargetPath;

            for (int i = 0; i < tbLocalAppNames.Length; i++)
            {
                tbLocalAppNames[i].Text = (string)Properties.Settings.Default["LocalAppName" + (i + 1)];
            }

            for (int i = 0; i < tbSourceFilePathLocalApps.Length; i++)
            {
                tbSourceFilePathLocalApps[i].Text = (string)Properties.Settings.Default["LocalAppFilePath" + (i + 1)];
            }

            for (int i = 0; i < tbSetPointFileLocalApps.Length; i++)
            {
                tbSetPointFileLocalApps[i].Text = (string)Properties.Settings.Default["SetPointLocalApp" + (i + 1)];
            }

            for (int i = 0; i < cbActivateLocalApps.Length; i++)
            {
                cbActivateLocalApps[i].Checked = (bool)Properties.Settings.Default["LocalAppAktiv" + (i + 1)];
            }

            for (int i = 0; i < cbActivateCode2LocalApps.Length; i++)
            {
                cbActivateCode2LocalApps[i].Checked = (bool)Properties.Settings.Default["ActivateCode2LocalApp" + (i + 1)];
            }         
          
        }

Für die Save Methoden auch.


public void SaveLocalPathConfigSettings()
        {
            Properties.Settings.Default.TargetPath = this.txtChooseTargetPath.Text;


            for (int i = 0; i < tbLocalAppNames.Length; i++)
            {
                Properties.Settings.Default["LocalAppName" + (i + 1)] = tbLocalAppNames[i].Text;
            }

            for (int i = 0; i < tbSourceFilePathLocalApps.Length; i++)
            {
                Properties.Settings.Default["LocalAppFilePath" + (i + 1)] = tbSourceFilePathLocalApps[i].Text;
            }

            for (int i = 0; i < tbSetPointFileLocalApps.Length; i++)
            {
                Properties.Settings.Default["SetPointLocalApp" + (i + 1)] = tbSetPointFileLocalApps[i].Text;
            }

            for (int i = 0; i < cbActivateLocalApps.Length; i++)
            {
                Properties.Settings.Default["LocalAppAktiv" + (i + 1)] = cbActivateLocalApps[i].Checked;
            }

            for (int i = 0; i < cbActivateCode2LocalApps.Length; i++)
            {
                Properties.Settings.Default["ActivateCode2LocalApp" + (i + 1)] = cbActivateCode2LocalApps[i].Checked;
            }

            Properties.Settings.Default.Save();
        }
Zitat
Edit: Alternativ dazu könntest du eine eigene "Settings.cs" anlegen (ruhig auch im Unterordner Properties) mit
namespace <ProjectNamespace>.Properties

Das habe ich gemacht aber das war es schon dafür brauche ich sehr viel Zeit.
Mein Problem ist zu verstehen wo was hingehört.

Es gibt zum Beispiel die Regel das man aus einer Klasse nicht auf die Controls zugreifen soll sondern Events dafür nutzt.
Man ist das kompliziert.
In der SPS zum Beispiel wenn ein Baustein zu groß wird kann ich einfach einen Teil raus nehmen
und in einen anderen Baustein packen und den Baustein dann aufrufen.

Unter anderem bin ich dabei dies hier zu lesen.
[FAQ] Kommunikation von 2 Forms
und das hier.
Zugriff von anderer Klasse auf Window Control

Aber es wäre toll wenn ich es schaffen würde alles was mit den Properties.Settings zu tun hat in die Settings.cs auszulagern.
Zitat
(ich benutze dafür auch immer using Properties;, damit ich Properties nicht mehr explizit schreiben muß).

Darüber finde ich kein Beispiel das mir das erklärt.
Zitat
Und auch deine Click-Methoden kannst du stark verkürzen, z.B.

Da hast du mir ja die Arbeit netter Weise abgenommen vielen Dank.


private void ChooseSourcePathLocalApp_Click(object sender, EventArgs e)
        {
            var textBox = sender as TextBox;

            if (textBox != null)
            {
                if (folderBrowserDialog1.ShowDialog() == DialogResult.OK)
                {
                    textBox.Text = folderBrowserDialog1.SelectedPath;
                }
            }
        }

Aber vielen Dank für die tolle Hilfe und die Code-Snippets

Grüße Tommylik

Thema: Anzahl Checkbox checked als Wert für for Schleife
Am im Forum: Grundlagen von C#

Servus,

So, ich habe noch weiter gemacht und musste feststellen das, was ich Euch beim letzten Mal geschrieben habe, ist Blödsinn,
weil ich so ja nur in dem Test_Click Event die Arrays nutzen kann.
Ich habe das jetzt mal so umgebaut das ich es auf die ganze Mainform anwenden konnte. Habe einige hundert Zeilen
Code herausschmeißen können, weil ich viele Schleifen nutzen konnte.
Ich hänge die Datei mal an, weil sie trotzdem ich sie verkleinert habe noch über 800 Zeilen hat.
Wenn Ihr möchtet, könnt Ihr mir mal Eure Meinung sagen.

Was könnten meine Fehler sein das ein User Control größer wird wie die Vorlage?
Beim Erstellen des User Controls hat es genau die gleichen Maße wie die Steuerelemente auf meiner Form.
(3 Textboxen und 2 Checkboxen in einer Reihe angeordnet.)
Ziehe ich dann, dass User Control aus der Toolbox auf die Form, ist es fast doppelt so groß.

Eine Frage hätte ich noch.
Es sind viele Zeilen Code für die Propperties.Settings in der angehängten Datei.
Könnte man das auch verkleinern? Oder sogar in eine Klasse auslagern?

Wenn ja, gehe ich weiter auf die Suche.

Vielen Dank für Eure Hilfe.

Grüße Tommylik

Thema: Anzahl Checkbox checked als Wert für for Schleife
Am im Forum: Grundlagen von C#

Hallo,

Vielen Dank für die Antworten und für den Code-Snippet.

Ich tue mich sehr schwer damit, weil ich auch nicht weiß wann was genau wo hin muss.
Jetzt habe ich wieder eine neue Variante. Funktioniert, aber ob das richtig ist weiß ich nicht.
Also nach den Programmier Regeln.


public partial class MainForm : Form
    {      
        public MainForm()
        {
            InitializeComponent();          
        }

        private void Test_Click(object sender, EventArgs e)
        {
                TextBox[] tb = new TextBox[] { txtLocalAppName1, txtLocalAppName2, txtLocalAppName3, txtLocalAppName4, 
                txtLocalAppName5, txtLocalAppName6, txtLocalAppName7, txtLocalAppName8 };

                for (int i = 0; i < cb.Length; i++)
                {
                  tb[i].Enabled = (cb[i].Checked || string.IsNullOrEmpty(tb[i].Text));                 
                }
        }
Zitat
Wenn jemand eine Checkbox wieder auf unchecked setzt soll dann das zugehörige Textfeld wieder disabled werden ? Das fehlt in deinem Code.

Die Textboxen werden mit einem anderen Button (speichern) auf disable gesetzt wenn sie Text enthalten damit nichts geändert werden kann.
Das sind sozusagen Konfigurationstextboxen die einmal beschrieben werden.
Der TestButton wird ein Loginbutton der die Textboxen auf Enabled setzt wenn man Änderungen machen muss.

So funktioniert es wie ich es möchte. Ob es richtig ist und auch sinnvoll kann ich nicht beurteilen.

Mal eine Frage, wenn ich eine Liste erstelle und die Textboxen da rein schreibe kann ich doch über den Index auf die einzelnen
Textboxen zugreifen oder ?
Wenn ich mehrere Textboxen in einer Reihe habe plus eine Checkbox und daraus ein User Control machen würde
und dann dieses User Control (erstmal mit dem Designer) mehrmals untereinander auf der Form platziere und
dann diese User Controls in eine Liste packe, wie spreche ich dann die Textboxen in dem User Control an?
Und was wäre wenn da noch ein TabControl dazwischen liegt?

Ich werde das mal ausprobieren ich hoffe es klappt.

Ihr habt ja gesagt das ich noch einiges über die OOP lernen muss.
Es gibt sehr viel hier im I-Net und wie ich schon mal gesagt habe wird das meistens mit der Klasse Auto erklärt.
Ich werde hauptsächlich mit Verzeichnissen und Dateien arbeiten und verstehe nicht wie man OOP mit
solchen Elementen in Verbindung bringen kann. Ich hoffe ihr versteht mich was ich sagen möchte.
Ich habe schon einige Videos über OOP geschaut aber keines von den Videos kann mir behilflich sein
mit dem was ich machen möchte.
Gibt es vielleicht ein Buch was ich kaufen könnte mit dem ich OOP besser verstehen lerne?

Vielen Dank nochmal für Eure Hilfe.

Grüße Tommylik

Thema: Anzahl Checkbox checked als Wert für for Schleife
Am im Forum: Grundlagen von C#

Servus,

Vielen Dank für Eure Antworten.

Zitat
Kannst du nicht einfach mal den (Teil vom) Artikel anschauen?

Habe ich, aber ich verstehe das Beispiel leider nicht wie du vielleicht gehofft hast.


TextBox[] textBoxes = new TextBox[] { this.textBox1, this.textBox2, this.textBox3 };
Keine Ahnung wo das hinkommt im Code, das steht in dem Beispiel nicht mit dabei.

Ich habe es jetzt anders gelöst.


public partial class MainForm : Form
    {
         List<TextBox> txtLocalAppNameList = new List<TextBox>();         

        public MainForm()
        {
            InitializeComponent();

            txtLocalAppNameList.Add(txtLocalAppName1);
            txtLocalAppNameList.Add(txtLocalAppName2);
            txtLocalAppNameList.Add(txtLocalAppName3);
            txtLocalAppNameList.Add(txtLocalAppName4);
            txtLocalAppNameList.Add(txtLocalAppName5);
            txtLocalAppNameList.Add(txtLocalAppName6);
            txtLocalAppNameList.Add(txtLocalAppName7);
            txtLocalAppNameList.Add(txtLocalAppName8);              
        }

        private void Test_Click(object sender, EventArgs e)
        {
                checkBoxes = new CheckBox[8];

                checkBoxes[0] = chkActivateLocalApp1;
                checkBoxes[1] = chkActivateLocalApp2;
                checkBoxes[2] = chkActivateLocalApp3;
                checkBoxes[3] = chkActivateLocalApp4;
                checkBoxes[4] = chkActivateLocalApp5;
                checkBoxes[5] = chkActivateLocalApp6;
                checkBoxes[6] = chkActivateLocalApp7;
                checkBoxes[7] = chkActivateLocalApp8;

                for (int i = 0; i < checkBoxes.Length; i++)
                {
                    if (checkBoxes[i].Checked == true)
                    {
                        txtLocalAppNameList[i].Enabled = true;
                    }
                }
        }

So funktioniert es wenigstens. Button klicken und alle Textboxen sind Enable.
Ich bin aber sehr enttäuscht ich dachte man könnte, wenn man mit Listen und Arrays arbeite, viel mehr Code Zeilen einsparen.
Meine If Konstruktion hat 42 Zeilen (siehe Beispiel oben). Jetzt sind es auch nicht viel weniger.
Na ja es funktioniert das ist die Hauptsache.

Vielen Dank für Eure Hilfe nochmal.

Grüße Tommylik

Thema: Anzahl Checkbox checked als Wert für for Schleife
Am im Forum: Grundlagen von C#

Hallo,

Vielen Dank für Eure Antworten.

Zitat
Bei dir scheinen wirklich die Grundlagen der OOP noch nicht zu sitzen.

Ich habe bisher noch nichts gefunden das mir das erklären könnte.
90% aller Videos oder Tutoriell erklären das mit der Klasse Auto.

Zitat
Und wie Abt schrieb, wenn du die Listen dann als Klassenmember anlegst (und im Konstruktor - nach InitializeComponent() - füllst), dann werden diese auch nicht jedesmal wieder neu angelegt.

Also nach dem InitializeComponent();
Ich habe das jetzt so umgesetzt:


public partial class MainForm : Form
    {      
         List<TextBox> txtLocalAppNameList = new List<TextBox>();   
         CheckBox[] checkBoxes;    

        public MainForm()
        {
            InitializeComponent();

                txtLocalAppNameList = new List<TextBox>();
                
                txtLocalAppNameList.Add(new TextBox { Text = txtLocalAppName1.Text });
                txtLocalAppNameList.Add(new TextBox { Text = txtLocalAppName2.Text });
                txtLocalAppNameList.Add(new TextBox { Text = txtLocalAppName3.Text });
                txtLocalAppNameList.Add(new TextBox { Text = txtLocalAppName4.Text });
                txtLocalAppNameList.Add(new TextBox { Text = txtLocalAppName5.Text });
                txtLocalAppNameList.Add(new TextBox { Text = txtLocalAppName6.Text });
                txtLocalAppNameList.Add(new TextBox { Text = txtLocalAppName7.Text });
                txtLocalAppNameList.Add(new TextBox { Text = txtLocalAppName8.Text });

               checkBoxes = new CheckBox[8]; 
               
                checkBoxes[0] = chkActivateLocalApp1;
                checkBoxes[1] = chkActivateLocalApp2;
                checkBoxes[2] = chkActivateLocalApp3;
                checkBoxes[3] = chkActivateLocalApp4;
                checkBoxes[4] = chkActivateLocalApp5;
                checkBoxes[5] = chkActivateLocalApp6;
                checkBoxes[6] = chkActivateLocalApp7;
                checkBoxes[7] = chkActivateLocalApp8;                     
        }

        private void Test_Click(object sender, EventArgs e)
        {      
                for (int i = 0; i < checkBoxes.Length; i++)
                {
                    if (checkBoxes[i].Checked == true)
                    {
                        txtLocalAppNameList[i].Enabled = true;                       
                    }
                }
          }

So funktioniert es auch nicht keine Ahnung warum.
Ist es wenigstens ein bisschen richtig, weil da würde ich mich echt freuen.
Man ist das kompliziert.

Grüße Tommylik

Thema: Anzahl Checkbox checked als Wert für for Schleife
Am im Forum: Grundlagen von C#

Hallo TH69,

Ich war leider einige Zeit Arbeitstechnisch wo anders eingesetzt so das ich keine Zeit hatte.

Vielen Dank für deine letzte Antwort.
Das muss ich mir noch alles genauer anschauen und noch mehr lesen.

Aber ich habe jetzt erstmal deine Vorschlag mit dem Herumexperimentieren in angriff
genommen und will erstmal mehr mit Listen und Arrays machen.
Es bringt mir nicht Steuerelemente dynamisch erstellen zu können, wenn ich doch noch
nicht weiß wie ich z.B. alle Textboxen die auf einem TabPage sind in eine Liste bekomme.

Und ich denke das ist hier jetzt mein Problem.

Ich möchte folgendes mit einer Liste und for Schleife erledigen.


private void Test_Click(object sender, EventArgs e)
        {           
                 if (chkActivateLocalApp1.Checked)
                {
                    txtLocalAppName1.Enabled = true;                    
                }

                if (chkActivateLocalApp2.Checked)
                {
                    txtLocalAppName2.Enabled = true;                   
                }

                if (chkActivateLocalApp3.Checked)
                {
                    txtLocalAppName3.Enabled = true;                   
                }

                if (chkActivateLocalApp4.Checked)
                {
                    txtLocalAppName4.Enabled = true;                   
                }

                if (chkActivateLocalApp5.Checked)
                {
                    txtLocalAppName5.Enabled = true;                  
                }

                if (chkActivateLocalApp6.Checked)
                {
                    txtLocalAppName6.Enabled = true;                   
                }

                if (chkActivateLocalApp7.Checked)
                {
                    txtLocalAppName7.Enabled = true;                   
                }

                if (chkActivateLocalApp8.Checked)
                {
                    txtLocalAppName8.Enabled = true;                  
                }       
        }

Mein Versuch mit einer Liste und Schleife.
Wenn ich mit dem Debugger und Haltepunkte schaue sind alle Werte vorhanden wie es sein sollte
aber es wird kein Textfeld auf Enabled gesetzt.
Mit der Code Variante oben schon.

Wo ist mein Fehler??


private void Login_Click(object sender, EventArgs e)
        {
                 List<TextBox> txtLocalAppNameList = new List<TextBox>
                {
                new TextBox { Text = txtLocalAppName1.Text },
                new TextBox { Text = txtLocalAppName2.Text },
                new TextBox { Text = txtLocalAppName3.Text },
                new TextBox { Text = txtLocalAppName4.Text },
                new TextBox { Text = txtLocalAppName5.Text },
                new TextBox { Text = txtLocalAppName6.Text },
                new TextBox { Text = txtLocalAppName7.Text },
                new TextBox { Text = txtLocalAppName8.Text }
                };      

                CheckBox[] checkBoxes = new CheckBox[8];

                checkBoxes[0] = chkActivateLocalApp1;
                checkBoxes[1] = chkActivateLocalApp2;
                checkBoxes[2] = chkActivateLocalApp3;
                checkBoxes[3] = chkActivateLocalApp4;
                checkBoxes[4] = chkActivateLocalApp5;
                checkBoxes[5] = chkActivateLocalApp6;
                checkBoxes[6] = chkActivateLocalApp7;
                checkBoxes[7] = chkActivateLocalApp8;

                for (int i = 0; i < checkBoxes.Length; i++)
                {
                    if (checkBoxes[i].Checked == true)
                    {
                        txtLocalAppNameList[i].Enabled = true;                       
                    }
                }
        }

Mit dem 2. Code habe ich keinen Code mehr der sich widerholt aber dennoch viel zu viele Codezeilen.
Wie kann ich das besser machen?

Vielen Dank noch mal für deine Hilfe.

Grüße Tommylik

Thema: Fragen zur Schnittstelle Sharp7 (C# - S7)
Am im Forum: Code-Reviews

Guten Abend Community,

Ich habe folgendes im I-Net gefunden.
Sharp7 Manual
Demoprojekte

Mit dieser Anleitung konnte ich mich erfolgreich über einer Winforms mit einer S7 verbinden.
Meine MainForm habe ich mit angehängt.

Es gibt 2 Sache die ich einfach nicht kapiere. Kann mir einer von Euch das bitte erklären.
Warum steht ComponentResult (in grüner Schrift) zwischen Private und LeakResult() und was bedeutet das?
Meistens steht da private void oder bool oder int ... aber in blauer Schrift.

Warum wird in der Methode gleich eine neue Instanz von ComponentResult erstellt?


private ComponentResult LeakResult()
        {
            ComponentResult result = new ComponentResult();
			
            // Reads the buffer.
            int dbNumber = short.Parse(txtDBNr.Text);
            int offset = short.Parse(txtDBOffsetNr.Text);
            int laenge = short.Parse(txtDBSizeNr.Text);

            byte[] buffer = new byte[laenge];

            client.DBRead(dbNumber, offset, laenge, buffer);

            return result;
        }

Ich würde gerne die GUI mit den Textboxen von den SPS Koponenten trennen
und alles was zwischen #region SPS Methoden #endregion steht in eine Klasse auslagern.
Geht das mit diesem Code und lohnst sich der Aufwand überhaupt.?

Grüße Tommylik

Thema: Anzahl Checkbox checked als Wert für for Schleife
Am im Forum: Grundlagen von C#

Guten Abend,

@ TH69
Vielen Dank für die Menge an Informationen. Es ist sehr interessant und macht viel Spaß das jetzt rauszufinden.

Hier meine ersten geh versuche mit Dynamischen Laden. Ich habe die Checkbox und die vier Textboxen genommen.
Das TabelLayoutPanel habe ich mal weggelassen. Funktioniert noch nicht so richtig.
Es wird die Checkbox angezeigt und die letzte Textbox. Die 3 Textboxen da zwischen fehlen.

Ich dachte es liegt vielleicht daran das ich das nicht im Form-Konstruktor nach InitializeComponent aufrufe,
sondern mit Button aufgerufen habe. Aber das ist egal.


public partial class Form1 : Form
    {
        public Form1()
        {
            InitializeComponent();
        }

        // Variable Textboxen
        private TextBox[] myTextBoxes;
        
        private void button2_Click(object sender, EventArgs e)
        {
             CheckBox checkBox1 = new CheckBox();

            // 
            // checkBox1
            // 
            checkBox1.AutoSize = true;
            checkBox1.Location = new System.Drawing.Point(10, 115);
            checkBox1.Name = "checkBox1";
            checkBox1.Size = new System.Drawing.Size(15, 15);
            checkBox1.TabIndex = 1;
            checkBox1.Text = "checkBox1";
            checkBox1.UseVisualStyleBackColor = true;

            myTextBoxes = new TextBox[4];
            for (int i = 0; i < myTextBoxes.Length; i++)
            {

                // Neue TextBoxen erzeugen
                myTextBoxes[i] = new TextBox();

                // 
                // txtAppName
                // 
                myTextBoxes[i].Font = new System.Drawing.Font("Consolas", 12F, System.Drawing.FontStyle.Regular, System.Drawing.GraphicsUnit.Point, ((byte)(0)));
                myTextBoxes[i].Location = new System.Drawing.Point(33, 107);
                myTextBoxes[i].Name = "txtAppName" + i;
                myTextBoxes[i].Size = new System.Drawing.Size(250, 26);
                myTextBoxes[i].TabIndex = 2;

                // 
                // txtFileNameApp
                //                 
                myTextBoxes[i].Font = new System.Drawing.Font("Consolas", 12F, System.Drawing.FontStyle.Regular, System.Drawing.GraphicsUnit.Point, ((byte)(0)));
                myTextBoxes[i].Location = new System.Drawing.Point(292, 107);
                myTextBoxes[i].Name = "txtFileNameApp" + i;
                myTextBoxes[i].Size = new System.Drawing.Size(200, 26);
                myTextBoxes[i].TabIndex = 3;

                // 
                // txtSourceFilePathApp
                // 
                myTextBoxes[i].Font = new System.Drawing.Font("Consolas", 12F, System.Drawing.FontStyle.Regular, System.Drawing.GraphicsUnit.Point, ((byte)(0)));
                myTextBoxes[i].Location = new System.Drawing.Point(500, 107);
                myTextBoxes[i].Name = "txtSourceFilePathApp" + i;
                myTextBoxes[i].Size = new System.Drawing.Size(280, 26);
                myTextBoxes[i].TabIndex = 4;

                // 
                // txtExtApp
                // 
                myTextBoxes[i].Font = new System.Drawing.Font("Consolas", 12F, System.Drawing.FontStyle.Regular, System.Drawing.GraphicsUnit.Point, ((byte)(0)));
                myTextBoxes[i].Location = new System.Drawing.Point(788, 107);
                myTextBoxes[i].Name = "txtExtApp" + i;
                myTextBoxes[i].Size = new System.Drawing.Size(80, 26);
                myTextBoxes[i].TabIndex = 5;
                

                Controls.Add(checkBox1);
                // TextBox auf dem Formular plazieren
                Controls.Add(myTextBoxes[i]);

            }
        }
    }

Was ist falsch an diesem Code? Ich bekomme ja keinen Fehler. Irgendetwas mit dem Zeichnen passt da nicht.

@ BerndFfm

Vielen Dank auch dir für die ganzen Code Snippets.

Zitat
Ich glaube ja immer noch dass Dir die Anzahl der angeklickten Checkboxen überhaupt nichts nützt.
Das was Du oben beschrieben hast würde ich so machen :

Ja, das ist richtig und hat ja TH69 auch schon gesagt.

Was bedeutet ExecLine? In Google finde ich nichts was mir das erklären könnte. Visual Studio kennt es auch nicht.

Vielen Dank an alle für die tolle Hilfe.

Grüße Tommylik

Thema: Anzahl Checkbox checked als Wert für for Schleife
Am im Forum: Grundlagen von C#

Hallo TH69,

Zitat
Wie schon geschrieben, nützt dir die Anzahl der gecheckten CheckBoxen gar nichts, da du dann ja immer noch nicht die zugehörigen Indizes weißt (ich hoffe, du verstehst, wie unlogisch dies daher ist?).
Leider verstehe ich es nicht. Aber, wenn du sagst, es nützt mir nicht dann will ich den Weg gar nicht weiter verfolgen.
Zitat
Sind denn die 10 Reihen fix oder kann es auch mehr oder weniger geben?
Aber alleine schon das manuelle Erzeugen der einzelnen Controls im Designer ist doch viel zu aufwendig (insb. falls mal Änderungen erfolgen sollen).
Ja die sind Fix. Aber du hast recht, es ist mühselige Feinarbeit.
Zitat
Erzeuge eine Methode zum Hinzufügen einer Reihe (d.h. eine CheckBox und die vier TextBoxen - welche auch wieder mittels einer Methode implementiert sein sollte) und rufe dann in einer Schleife diese auf.
Wenn du nicht genau weißt, wie der Code dafür aussehen soll, dann schau dir in der bisherigen zugehörigen "designer.cs"-Datei den Code dafür an und kopiere ihn.
Die eine CheckBox und die vier TextBoxen kann ich mit einem Usercontrol machen oder ist das Usercontrol schon zu viel?
Die Methode "Steuerelemente_hinzufügen füttere ich mit dem Code aus dem Designer, um es mir leicht zu machen.
Das Aufrufen mit der Schleife verstehe ich nicht so richtig da ich ja nicht weiß, wo oder wie ich den Wert für den Schleifenzähler festlegen soll.
Zitat
Und dann kannst du beim TableLayoutPanel die Methode GetControlFromPosition in einer Schleife aufrufen, um an die einzelnen Check- und TextBoxen zu gelangen (d.h. entsprechend casten).
Danke für den Link muss ich mir anschauen habe ich noch nicht gemacht.
Funktioniert die Methode auch noch wenn das TableLayoutPanel auf einem Tabcontrol platziert ist??
Zitat
PPS: Magic Strings sind die hartcodierten Namen deiner Controls (d.h. wenn man im Designer mal den falschen Namen oder Index angibt, knallt dein Code).
Meinst du mit hartkodierten Namen, wenn ich einem Steuerelement einen anderen Namen gebe als der Designer?
z.B. button1 vom Designer und ich Schreibe btnVerschiebeDateien?

Vielen Dank nochmal für deine Hilfe.

Grüße Tommylik


Thema: Anzahl Checkbox checked als Wert für for Schleife
Am im Forum: Grundlagen von C#

Guten Morgen,

Ich sage mal Danke an alle die mir geschrieben haben.

@TH69

Zitat
Stattdessen würde man passende Container-Controls (z.B. DataGridView oder TableLayoutPanel) benutzen

Ich habe mir die Mühe gemacht und habe ein TableLayoutPanel erstellt genauso wie ich es schon auf der tpSaveFile habe. Siehe Bilder.
Ich habe in beiden Fällen 4 Textboxen auf 10 Reihen mit der Checkbox vorne dran.
Damit das Tool überhaupt was machen kann, braucht man 1 aktivierte Zeile (Checkbox) mit den 4 ausgefüllten Textboxen.

Textbox1 = Applikationsname - Nur informativ, weil es möglich sein kann eine App mehrmals zu nutzen. Für den Ablauf uninteressant.
Textbox2 = Filename to save - Unter welchen Namen möchtest du die Dummy Dateien speichern.
Textbox3 = File SourcePath - Wo sind die Quelldateien die verschoben werden.
Textbox4 = Welche Dateiendung haben die Dateien.

So das muss man für jede Zeile machen die man aktiviert. Es ist ein Individuelles zusammenstellen der Strings.
Ein Beispiel von einer unserer Anlagen die 5 verschiedene Applikationen hat.
-Dadurch habe ich 5 unterschiedliche Dateinamen für die Dummy-Dateien
- 5 Quellverzeichnisse
- 3 verschiedene und 2 gleiche Dateiendungen.

Ob mit TableLayoutPanel oder ohne ich muss die Strings über die Textboxen zusammenstellen damit der Anwender
die Freiheit hat die Bezeichnungen zu nutzen wie er es möchte. Bei mir bekommen die Dummy Dateien den App-Namen.
Ein anderer Anwender möchte sie aber anders benennen dann soll er das dürfen.
Zitat
Der ganze Ansatz mittels X per Designer erstellten Check- und TextBoxen ist schon falsch (unprofessionell).

In meinem Fall jetzt, wie kann mir das TableLayoutPanel dabei behilflich sein das es besser wird.


@ JimStark

Kannst du mir sagen was für dich Magic Strings sind damit ich weiß, was ich nicht tun sollte?

@ Abt
Zitat
Magst den nicht lesen, mh? :-)

Ich habe den gelesen und jetzt schon 2 Mal, nachdem TH69 das auch erwähnt hatte.
Und du hast bestimmt auch recht, dass das der beste Weg ist. Wie du schon gesagt hast,
gehört das, was ich hier zusammen bastle zu den hingeklatschen Tools.
Es sind um die 1500 Zeilen Spaghetti Code, weil ich alles 10 Mal angelegt habe. Jede Zeile die aktiviert wird, ruft eine Methode auf.
Aber egal dafür, das ich keine Ahnung habe, bin ich aber stolz darauf, was ich geschafft habe.
Zitat
Trotzdem - wie Du hier an der Resonanz der Helfer auch erkennen kannst - ist Binding der richtige Weg, der Dir vor allem in der Zukunft viel Stress und Codeaufwand ersparen und viel Logik erleichtern wird.


Ich denke das es Angst ist das ich es nicht wieder zum Laufen bekomme, wenn ich das jetzt umbaue mit List-Controls, Linq und Data-Binding nutze was sehr kompliziert aussieht.
Das Programm ist wirklich Mini. Es verbindet sich mit der SPS. Bekommt von der SPS ein Signal.
Und verschiebt alle Dateien (aktivierte Checkbox), die im Quellverzeichnis sind in das Zielverzeichnis.


@ BerndFfm

Zitat
Es wäre gut, wenn der Autor mal beschreiben würde, was er überhaupt machen will.

Das was ich zusammengebastelt habe funktioniert ja schon.
Ich wollte die 10 Methoden, die ich aufrufe auf eine Methode einkürzen.

Dafür wollte ich nur wissen wie ich die Anzahl der gecheckten Checkboxen mit Lenght in einer For-Schleife nutzen kann.


   
      for (int i = 0; i < "AnzahlCheckboxen.checked".Length; i++)                      


So das wärs jetzt vielen Dank für die Hilfe.

Grüße Tommylik

Thema: Anzahl Checkbox checked als Wert für for Schleife
Am im Forum: Grundlagen von C#

Hallo Bernd,

Vielen Dank für deine Antwort.

Dein Beispiele schaue ich mir mal an mal sehen ob ich es vervollständigen kann.

@Papst

Auch dir vielen Dank für deine Hilfe.

Zitat
Mit Databinding würdest du jetzt einfach die ViewModel Instanzen zählen, bei denen die IsChecked Property true ist.
Data Binding muss ich mir erstmal anschauen weiß ich noch gar nichts drüber.
Zitat
Verstehe ich richtig, dass du nur über die Checkboxen iterieren willst Checked sind, aber deren Index brauchst um Controlnamen zusammenzubauen?

Ja:
Wie viele Checkboxen sind aktiviert und der Wert soll dann der For Schleife übergeben werden.


​for (int i = 0; i < "AnzahlCheckboxen.checked".Length; i++)

Nein:
Ich weiß jetzt nicht genau was du mit Controlnamen zusammenzubauen meinst aber
ich würde dazu sagen das der String-Wert aus der TextBox "txtSourceFilePathApp" + #Index der Checkbox die aktiviert ist, an die string Variable "sourceFilePath" übergeben wird.


Control[] c1 = this.Controls.Find("txtSourceFilePathApp" + i, true);
                string sourceFilePath = c1[0].Text;             


Hier nochmal der ganze Code.


private void BtnTest_Click(object sender, EventArgs e)
        {          
           ======================================
            Das kommt weg weil Gesamtanzahl kann ich nicht gebrauchen.
            CheckBox[] controls = tpFileSave.Controls.OfType<CheckBox>().ToArray();            
            
            ======================================

            for (int i = 0; i < "AnzahlCheckboxen.checked".Length; i++)
            {
                Control[] c1 = this.Controls.Find("txtSourceFilePathApp" + i, true);
                string sourceFilePath = c1[0].Text;                

                Control[] c2 = this.Controls.Find("txtFileNameApp" + i, true);
                string fileName = c2[0].Text;                

                Control[] c3 = this.Controls.Find("txtExtApp" + i, true);
                string ext = c3[0].Text; 

                ComponentResult cr = LeakResult();

                string praegeCodeNrFileName = cr.PraegeCode;
                string praegeCodeNrFolderName = cr.FolderName;          
                string targetPath = txtChooseTargetPath.Text;

                MoveFiles(sourceFilePath, targetPath, praegeCodeNrFolderName);
                DummyDatei(praegeCodeNrFolderName, praegeCodeNrFileName, fileName, targetPath, ext);
            }

        }

Zitat
oder auf etwas Linq zurückgreifen

Ich denke wenn du auch schon Databinding empfiehlst sollte ich nicht mit Linq anfangen.
Was bedeuten eigentlich diese beiden Pfeile? Ich habe nachgelesen es sind Lambda Expression aber was sagen sie aus?

nochmal
@Bernd

Ich hoffe du verstehst es jetzt besser.

Vielen Dank nochmal für Eure Hilfe.

Grüße Tommylik





Thema: Anzahl Checkbox checked als Wert für for Schleife
Am im Forum: Grundlagen von C#

Hallo Abt,

Vielen Dank für deine Antwort.

Zitat
wieso verwendest Du nicht einfach Data Binding, was man immer tun sollte?

Jetzt meine Frage vorweg: Wie kommst du auf Data Binding wenn ich so wenig Infos gebe?

Tut mir Leid das ich den Thread im falschen Forenbereich geschrieben habe. Kannst du es ändern oder ändern lassen?
Damit ich dazu lerne warum ist es der falsche Forenbereich?

Also es ist eine WinForms. Ich habe ein tabControl mit 3 tabPages.
Die eine tabPage heißt tpFileSave. Auf diesem tabPage sind mehrer Textboxen untereinander angeordnet.
Vorne an erste Stelle ist immer eine Checkbox die diese Textboxen sozusagen aktiviert.
Die Anzahl der Schleifendurchgänge werden durch die angeklickten Checkboxen bestimmt.
Vorher hatte ich zu jeder Checkbox auch einen Button und somit auch die entsprechenden Methoden.
Bis auf einen Button habe ich alle anderen gelöscht. Jetzt soll das alles mit einem Button ablaufen.

Ich hoffe diese Info ist ausreichend.

Grüße Tommylik

Thema: Anzahl Checkbox checked als Wert für for Schleife
Am im Forum: Grundlagen von C#

Guten Abend,

Ich komme einfach nicht weiter mit meinem Problem.

Damit bekomme ich die Gesamtanzahl der Checkboxen auf der tabPage.


CheckBox[] controls = tpFileSave.Controls.OfType<CheckBox>().ToArray();

Und controls.Length kann ich auch für die For Schleife nutzen.


private void BtnTest_Click(object sender, EventArgs e)
        {
            CheckBox[] controls = tpFileSave.Controls.OfType<CheckBox>().ToArray();        

            for (int i = 0; i < controls.Length; i++)
            {
                Control[] c1 = this.Controls.Find("txtSourceFilePathApp" + i, true);

                string sourceFilePath = c1[0].Text;
                
                Control[] c2 = this.Controls.Find("txtFileNameApp" + i, true);

                string fileName = c2[0].Text;

...
...


Ich brauche aber nicht die Gesamtanzahl der Checkboxen sondern die Anzahl der Checkboxen die Checked sind.
Und das möchte ich der For Schleife übergeben.

Hiermit bekomme ich den Wert weiß aber nicht wie ich das der Schleife übergeben kann,
weil ich daraus nicht Length entnehmen kann.


int i = tpFileSave.Controls.OfType<CheckBox>().Count(c => c.Checked);

Wer ist bereit mir bei meinem Problem zu helfen?

Vielen Dank

Grüße Tommylik





Thema: Jede Datei überprüfen - ggf. Dummy Datei erstellen.
Am im Forum: Grundlagen von C#

Servus Abt,

Vielen Dank für deine Antwort und die vielen Denkanstöße.
Die Links waren auch sehr hilfreich. Dadurch bin ich zu einigen anderen interessante Seiten gekommen.
Vor allem hat mir dieses Video geholfen. https://www.youtube.com/watch?v=QKX9VJAvGWM.

Zitat
Vorher prüfen war schon der richtige Weg

Sorry da habe ich noch vergessen dir zu erklären das die Situation es so verlangt.
Aber gewiss hast du im normal Fall Recht.
Da ist eine Anlage wo Bauteile gefertigt werden. Auf dem ganzen Weg bis das BT fertig ist,
werden Dateien mit Prozessdaten von den diversen Applikationen auf ihren PCs abgelegt.
Wenn das Teil dann fertig ist müssen so wie so alle Dateien in den Ziel Ordner verschoben werden.
Die Anlage muss weiter laufen deswegen wird nicht vor dem verschieben geschaut ob Dateien fehlen
um die Anlage anzuhalten, sondern erst danach wen sich der Fall wiederholen sollte.
Hat auch etwas mit der Politik der Firma zu tun wie sie das haben möchte auf Fehler zu reagieren.
Zitat
dass Du nicht unbedingt nur das Feedback bekommst, was Du willst

Da hast du Recht und das weiß ich auch und es kann ja auch alles so bleiben.
Ich dachte auch mehr so wie als wenn man einen Aufsatz abgegeben hat.
Rote Kringel drunter und man weiß da hat man drüber nachzudenken.
Zitat
dass Du Dich bisher nie mit strukturellem Code-Aufbau beschäftigt hast

Da hast du vollkommen Recht. Das was ich jetzt umsetzen möchte läuft derzeit schon
als VBA Variante in eine Visualisierungssoftware in der Runtime.
Da diese Runtime von der Visu nicht Multitasking fähig ist, kann es möglich sein das man
die Visu nicht nutzen kann wenn gerade in diesem Moment ein VBA Code aufgerufen wird.
Gerade bei verschieben der Dateien könnte es etwas länger Dauern es sind ja nicht wenig Dateien.
Somit habe ich darüber nachgedacht wie ich das verschieben der Dateien anders lösen kann.
Zitat
Erfahrung kommt mit der Zeit, aus Fehlern, aus Feedback. Die kann Dir keiner Rüberwerfen, die musst Dir selbst nehmen/machen.

Jetzt bin ich verwirrt.
Die Erfahrung bekomme ich mit der Zeit da hast du Recht und auch aus Fehlern lernt man, aber wenn
ich etwas zeige, was ich gemacht habe und niemand sagt etwas dazu dann habe ich damit keinen Feedback bekommen und weiß somit nicht ob es Richtig oder Falsch ist.

So ich wollte nicht nur dir Antworten sondern auch noch mal zeigen was ich jetzt neues habe.


namespace PDE_2
{
    public partial class Form1 : Form
    {
        private const string TargetPath = @"D:\S7_Export\AppData\"; 
        private const string SourcePath = @"D:\S7_Export\AppData\"; 
        // Absicht einmal für das verschieben und einmal für die Dummy-Datei erstellen.

        private const string PathOfCamera15 = @"D:\S7_Export\Sensopart\x015id02xa1";
        private const string JobFileName = "_x015id02xa1_Job";        
        private const string Extension = "*.jpg";         

        /// <summary>
        /// Dateien verschieben
        /// </summary>
        /// <param name="rootPath"></param>
        /// <param name="targetPath"></param>
        /// <param name="folder"></param>
        private void FileMove(string rootPath, string targetPath, string folder)
        {
            string[] files = Directory.GetFiles(rootPath);
            foreach (string file in files)
            {
                string destinationFolder = targetPath + folder + "\\";
                File.Move(file, $"{destinationFolder}{Path.GetFileName(file) }");
            }
        }
                 
        /// <summary>
        /// Dummy Datei erstellen wenn Dateien fehlen.
        /// </summary>
        /// <param name="sourcePath"></param>
        /// <param name="folder"></param>
        /// <param name="fileIB"></param>
        /// <param name="jobFileName"></param>
        /// <param name="extension"></param>
        private void DummyDatei(
            string folder, string fileIB, string jobFileName, string sourcePath, string extension)
        {
            for (int i = 0; i < 6; i++)
            {
                string fullSourcePath = sourcePath + folder + "\\";
                string fullFileName = $"{fileIB}{jobFileName}{i + 1}{extension}";                
                string[] fileEntries = Directory.GetFiles(fullSourcePath, fullFileName, SearchOption.TopDirectoryOnly);

                if (fileEntries.Length > 0)
                {
                    string fullPath = fullSourcePath + fullFileName;
                    File.Exists(fullPath);
                }
                else
                {
                    string dummyDatei = $"{jobFileName}{i + 1}_NoFile.txt";                    
                    File.WriteAllText(Path.Combine(sourcePath, folder, dummyDatei), string.Empty);
                }
            }
        }

       /// <summary>
        /// Bilddateien vom Mutternstanzen x15id02xa1 verschieben.
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void BtnTest2_Click(object sender, EventArgs e)
        {            
            string fileIB = "21050612325";
            string folder = "21050612325L";
            string jobFileName = JobFileName;
            string sourcePath = SourcePath;
            string extension = Extension;
            string rootPath = PathOfCamera15;
            string targetPath = TargetPath;

            FileMove(rootPath, targetPath, folder);            

            DummyDatei(folder, fileIB, jobFileName, sourcePath, extension);
        }
    }
}

So wie ich das jetzt gemacht habe mit den Konstanten und die 2 separaten Methoden
ist das schon zu gebrauchen? Ich persönlich der keine Ahnung hat finde es besser.

Dann noch eine Frage zu diesem Buch:
Clean Code - Refactoring, Patterns, Testen und Techniken für sauberen Code: Deutsche Ausgabe
Lohnt sich dieses Buch oder seit Ihr der Meinung das geht mit dem Internet alleine?

So vielen Dank nochmal für Eure Hilfe.

Servus Tommylik






Thema: Jede Datei überprüfen - ggf. Dummy Datei erstellen.
Am im Forum: Grundlagen von C#

Hallo an alle,

So nochmal vielen Dank an alle für Eure Erklärungen und Tipps.
Einerseits waren sie sehr gut und manchmal haben Sie mir nicht geholfen da ich es nicht Nachvollziehen konnte.
Ich habe festgestellt das was ich Ursprünglich wollte war nicht gut durchdacht.
Und habe es nochmal von ein anderen Perspektiven aus betrachtet und dann anders gelöst.
Ich verschiebe erst die Daten und prüfen dann alles was von Bedeutung ist.
Try und Catch für die Fehler die mit Datei Operationen passieren können habe ich noch nicht mit eingebaut,
weil ich noch am überlegen bin wie ich die Anzeige mache.
MessageBox möchte ich nicht nehmen da man die bestätigen muss und der Code läuft nicht weiter.
Ich hoffe das die Notation ein bisschen besser ist.
Es wäre schön, damit ich es in Zukunft besser machen kann, das ihr mir nur markiert was ich nochmal überdenken sollte.


 private void BtnTest2_Click(object sender, EventArgs e)
        {          
            // Nur für Testzwecke
            string fileIB = "21050612325";
            string folder = "21050612325L";
            string sourcePath = @"D:\S7_Export\AppData\" + folder + "\\";

            DirectoryInfo TargetDirectory = new DirectoryInfo(@"D:\S7_Export\AppData\" + folder);
            //if (dirInfo.Exists == false)
            //Directory.CreateDirectory(@"D:\S7_Export\AppData\" + folder);

            // Bilddateien vom Mutternstanzen x15id02xa1 verschieben.
            List<String> foundFiles = Directory.GetFiles(@"D:\S7_Export\Sensopart\x015id02xa1\", "*.*", 
            SearchOption.AllDirectories).ToList();            
            foreach (string file in foundFiles)
            {
                FileInfo mFile = new FileInfo(file);
                mFile.MoveTo(TargetDirectory + "\\" + mFile.Name);
            }      
            
            // Dummy Datei erstellen wenn Dateien fehlen.
            for (int i = 0; i < 6; i++)         
            {
                string fullFileName = $"{fileIB}_x015id02xa1_Job{i + 1}*.jpg";
                string sourceFullPath = sourcePath + fullFileName;
                string[] fileEntries = Directory.GetFiles(sourcePath, fullFileName, SearchOption.TopDirectoryOnly);

                if (fileEntries.Length > 0)
                {
                    File.Exists(sourceFullPath);
                }
                else
                {
                    string dummyDatei = $"15id02_Job{i + 1}_NoFile.txt";
                    // Dummydatei im Zielordner erstellen
                    File.WriteAllText(Path.Combine(@"D:\S7_Export\AppData\", folder, dummyDatei), string.Empty);
                }
            }

            // Anzahl Dateien die verschoben wurden.
            LblAnzDateien.Text = Convert.ToString(TargetDirectory.GetFiles().Length);

            // Anzeige welche Dateien verschoben wurden in der ListBox 1.
            foreach (FileInfo file in TargetDirectory.GetFiles())
            {
                listBox1.Items.Add("Datei: " + file.Name);
            }

            // Anzeige welche Dateien fehlen in der ListBox 2.
            foreach (string foundFile in Directory.GetFiles(@"D:\S7_Export\AppData\" + folder, "*NoFile.txt", 
            SearchOption.TopDirectoryOnly))
            {
                listBox2.Items.Add("Datei: " + foundFile);
            }

            // Anzeige welche Dateien sind niO in der ListBox 2.           
            foreach (string foundFile in Directory.GetFiles(@"D:\S7_Export\AppData\" + folder, "*Fail.jpg", 
           SearchOption.TopDirectoryOnly))
            {
                listBox2.Items.Add("Datei: " + foundFile);
            }            
        }

Dann hätte ich zum Abschluss noch eine Frage über die Struktur des Aufbaus eines Projektes und würde mich freuen wenn Ihr mir Eure Meinung sagen würdet.

Wenn ich mehrere solche verschiebe Aktionen hätte und jeweils mit unterschiedlichen Pfad Angaben und auch welche über das Netzwerk, wäre es dann nicht besser das in einzelne Methoden / Klassen auszulagern?
Ich denke schon alleine wegen der Übersicht wäre das besser. Da ich keine Erfahrung habe bin ich mir nicht sicher. Und dann könnte ich doch alle Methoden in einer Methode aufrufen oder? Was ist schneller alles in einer Methode oder aufgeteilt auf mehrere?

Vielen Dank nochmal für Eure Hilfe.

Grüße Tommylik



Thema: Jede Datei überprüfen - ggf. Dummy Datei erstellen.
Am im Forum: Grundlagen von C#

Hallo dannoe,

Vielen Dank für deine Antwort und Code Beispiel.

Du hast hier die "String Interpolation" benutzt, in der Microsoft Hilfe steht das dies zur besseren Lesbarkeit beiträgt.


        string strZusatz = $"{strFile_IB}_x015id02xa1_Job{i + 1}_{filenameSuffix}.jpg";
        string strDummy = $"15id02_Job{i + 1}_{filenameSuffix}_Dummy.txt";

Kann man hier sagen das meine Variante zur ungarischen Notation zählt?

So hier nun meine Variante wegen der ungarischen Notation.
Ich hoffe, es ist schon etwas besser geworden.


private void MyExportTestMethodXyz(string fileIB, string folder, string filenameSuffix)
        {
            for (int i = 0; i < 6; i++)
            {
                string sourcePath = @"D:\S7_Export\Sensopart\x015id02xa1\";
                string fullFileName = $"{fileIB}_x015id02xa1_Job{i + 1}_{filenameSuffix}.jpg";
                string dummyDatei = $"15id02_Job{i + 1}_{filenameSuffix}_Dummy.txt";
                string sourceFullPath = sourcePath + fullFileName;
                string targetFullPath = @"D:\S7_Export\AppData\" + folder;
                string result = Path.GetFileName(sourceFullPath);
                string[] fileEntries = Directory.GetFiles(sourcePath, fullFileName, SearchOption.TopDirectoryOnly);

                if (fileEntries.Length > 0)
                {
                    Directory.Move(sourceFullPath, Path.Combine(targetFullPath, result));
                }
                else
                {
                    // Dummydatei im Zielordner erstellen
                    File.WriteAllText(Path.Combine(@"D:\S7_Export\AppData\", folder, dummyDatei), string.Empty);
                }
            }
        }

@OlafSt
Vielen Dank für deine Antwort war sehr hilfreich.

Vielen Dank nochmal für Eure Unterstützung.

Grüße Tommylik





Thema: Jede Datei überprüfen - ggf. Dummy Datei erstellen.
Am im Forum: Grundlagen von C#

Hallo dannoe,

Vielen Dank für deine Antwort.

Zitat
Außerdem: Welcher der Sätze ist leichter für dich zu verstehen:

Ist Eindeutung keine Frage. Für Euch ist das selbstverständlich
ich erkenne so was nicht. Ok jetzt vielleicht. Vielen Dank.

So meine geänderte Variante mit GetFileName. Funktioniert sehr gut.
Fast so wie ich es mir vorstelle.

Ein Schönheitsfehler hat das noch.
Weil ich nicht *.jpg nutzen kann so wie ich es möchte habe ich in den 2 Zeilen
die Wörter getauscht und rufe die Schleifen 2 x auf.
Wenn ich nur eine bräuchte, wäre es schöner.


string strZusatz = strFile_IB + "_x015id02xa1_Job" + (i + 1) + [color]"_Pass.jpg"[/color];
und
string strZusatz = strFile_IB + "_x015id02xa1_Job" + (i + 1) + [color]"_Fail.jpg"[/color];


private void BtnTest2_Click(object sender, EventArgs e)
        {
            // Nur für Testzwecke
            string strFile_IB = "21050612325";
            string strFolder = "21050612325";          
            
            for (int i = 0; i < 6; i++)
            {                
                string SourcePath = @"D:\S7_Export\Sensopart\x015id02xa1\";
                string strZusatz = strFile_IB + "_x015id02xa1_Job" + (i + 1) + "_Pass.jpg";
                string strDummy = "15id02_Job" + (i + 1) + "_Pass_Dummy.txt";
                string SourceFullPath = SourcePath + strZusatz;
                string TargetFullPath = @"D:\S7_Export\AppData\" + strFolder;
                string result = Path.GetFileName(SourceFullPath);
                string[] fileEntries = Directory.GetFiles(SourcePath, strZusatz, SearchOption.TopDirectoryOnly);

                if (fileEntries.Length > 0)
                {
                    Directory.Move(SourceFullPath, Path.Combine(TargetFullPath, result));
                }
                else
                {                    
                    //Dummydatei im Zielordner erstellen
                    File.WriteAllText(Path.Combine(@"D:\S7_Export\AppData\", strFolder, strDummy), string.Empty);
                }

            }

            for (int i = 0; i < 6; i++)
            {
                string SourcePath = @"D:\S7_Export\Sensopart\x015id02xa1\";
                string strZusatz = strFile_IB + "_x015id02xa1_Job" + (i + 1) + "_Fail.jpg";
                string strDummy = "15id02_Job" + (i + 1) + "_Fail_Dummy.txt";
                string SourceFullPath = SourcePath + strZusatz;
                string TargetFullPath = @"D:\S7_Export\AppData\" + strFolder;
                string result = Path.GetFileName(SourceFullPath);
                string[] fileEntries = Directory.GetFiles(SourcePath, strZusatz, SearchOption.TopDirectoryOnly);

                if (fileEntries.Length > 0)
                {
                    Directory.Move(SourceFullPath, Path.Combine(TargetFullPath, result));
                }
                else
                {
                    //Dummydatei im Zielordner erstellen
                    File.WriteAllText(Path.Combine(@"D:\S7_Export\AppData\", strFolder, strDummy), string.Empty);
                }

            }
        }

Vielen Dank noch mal für Eure Hilfe.

Grüße

Thema: Jede Datei überprüfen - ggf. Dummy Datei erstellen.
Am im Forum: Grundlagen von C#

Hallo ClaraSoft,

Vielen Dank für deine Antwort.

Ich hatte es mir angeschaut auch das Beispiel und als du das
mit dem Substring erwähnt hattest nochmal.
Aber, wenn ich nicht verstehe, was genau falsch ist oder
was Ihr mir damit sagen wollt, dann kann ich es nicht nutzen.

Du hast mir die Info gegeben:

Zitat
oder anders gesagt du brauchst kein Aufruf an substring.

Also verstehe ich jetzt das ich diese Zeile mit GetFileName erstellen soll.


string fileName = currentFile.Substring(sourceDirectory.Length + 1);

Aber warum? Das Verschieben der Dateien funktioniert ja.
Ist es mit GetFileName besser, sicherer oder ist die Vorlage aus der Doku nicht mehr aktuell???

Tut mir leid aber Abt hat mich mit dieser Code Zeile und nur mit dem Hinweis auf die Doku überfordert.

Trotzdem Danke für Eure Hilfe.

Grüße Tommylik




Thema: Jede Datei überprüfen - ggf. Dummy Datei erstellen.
Am im Forum: Grundlagen von C#

Hallo Abt,

Danke für deine Antwort.

Zitat
Zitat von Tommylik
string fileName = currentFile.Substring(sourceDirectory.Length + 1);

Path.GetFileName Methode (System.IO)

Tut mir Leid jetzt hältst du mich für Klüger als ich bin.
Ich weiß nicht was du mir damit sagen willst?
Irgendetwas an der Zeile austauschen?

Vor allem diese Zeile soll ich mir anschauen mit der ich auf Kriegsfuß stehe und dieses Substring??
Es gibt Sachen da kommste nicht dahinter.


string fileName = currentFile.Substring(sourceDirectory.Length + 1);

Vieleicht könntest du bitte noch was dazu sagen. z.B. Wo rauf ich achten soll?

Jetzt ist mir eine Idee gekommen. Sehr unschön und so professionell wir Ihr das machen
würdet bekomme ich es sowieso nicht hin aber es funktioniert.
Die For Schleifen 2 x aufrufen und nur die Wörter Pass und Fail anpassen.

Grüße Tommylik

Thema: Jede Datei überprüfen - ggf. Dummy Datei erstellen.
Am im Forum: Grundlagen von C#

Hallo Abt,

Vielen Dank für deine Antwort.

Dein Rat ist sehr hilfreich und ich habe auch gelesen aber vieles verstehe ich nicht.
Aber ich habe auch eine kleine Lösung gefunden mit dem * die Dateien zu verschieben.
Genauso wie es in der Doku steht.


               string sourceDirectory = @"D:\S7_Export\Sensopart\x015id02xa1";
                string archiveDirectory = @"D:\S7_Export\AppData\" + strFolder;

                var jpgFiles = Directory.EnumerateFiles(sourceDirectory, "*.jpg");

                foreach (string currentFile in jpgFiles)
                {
                    string fileName = currentFile.Substring(sourceDirectory.Length + 1);
                    Directory.Move(currentFile, Path.Combine(archiveDirectory, fileName));
                }                

Aber jetzt muss ich herausfinden wie ich diesen Code in den alten Code intrigiere um
jede Datei zu prüfen und wenn notwendig ein Dummy Datei erstellen.

Ich habe einerseits einen Schritt nach vorne gemacht aber auch wieder einen zurück.

Vielen Dank nochmal für deine Unterstützung

Tommylik

Thema: Jede Datei überprüfen - ggf. Dummy Datei erstellen.
Am im Forum: Grundlagen von C#

Hallo Palladin,

Ich habe doch noch eine Frage, weil ich heute die Situation damit hatte.

Von dir habe ich diesen guten Vorschlag bekommen.


string strZusatz = "_x015id02xa1_Job" + (i + 1) + "_*.*";

Ich habe wegen des illegalen Zeichens das *.* gegen _Pass.jpg ausgetauscht.


string strZusatz = "_x015id02xa1_Job" + (i + 1) + "_Pass.jpg";

In VBA hatte ich *.* genutzt, weil es vorkommen kann das die Dateien auch mit _Fail.jpg benannt werden können.
Kann ich die beiden Wörter irgendwie verodern das auch nach den Dateien mit "Fail" geschaut werden.

Ist dieses Zeichen || für eine Veroderung richtig?

Vielen Dank

Grüße Tommylik

Thema: Jede Datei überprüfen - ggf. Dummy Datei erstellen.
Am im Forum: Grundlagen von C#

Hallo dannoe,

Danke für deine Antwort.

Ja, das da, was falsch war, habe ich auch erkannt.
Ich habe es nun zum Laufen bekommen.


private void button1_Click(object sender, EventArgs e)
        {
            //ComponentResult CR = LeakResult();

            //string strFolder = CR.FolderName;
            //string strFile_IB = CR.PraegeCodeIB;
            string strFile_IB = "21050612325";
            string strFolder = "21050612325";

            string SourcePath = @"D:\S7_Export\Sensopart\x015id02xa1\";
            string TargetPath = @"D:\S7_Export\AppData\" + strFolder + "\\";                     

            for (int i = 0; i < 6; i++)
            {
                string strZusatz = "_x015id02xa1_Job" + (i + 1) + "_Pass.jpg";
                var strDummy = "15id02_Job" + (i + 1) + "_Dummy.txt";

                string strFileName;
                strFileName = string.Concat(strFile_IB, strZusatz);                
                
                string[] fileEntries = Directory.GetFiles(SourcePath, strFileName);

                string path = Path.Combine(SourcePath, strFileName);
                string path2 = Path.Combine(TargetPath, strFileName);

                if (fileEntries.Length > 0)             
                {
                    File.Move(path, path2);                    
                }
                else
                {
                    //Dummydatei im Zielordner erstellen
                    using (StreamWriter myWriter = File.CreateText(Path.Combine(@"D:\S7_Export\AppData\", strFolder, strDummy)))
                    {
                        myWriter.Close();
                    }
                }                  
                    
            }
            
        }

Die richtige Dummy Datei wird auch erstellt, wenn eine von den JPG-Dateien fehlt.

Könnt Ihr mir bitte sagen, ob noch gravierende Fehler drin sind, die ich nicht erkenne?
Nur, weil es funktioniert muss nicht alles richtig sein.
Die Notation muss ich machen das ist klar. Vielleicht könnt Ihr mir mal eine Sache markieren was schlechte Notation ist.
Die File.Create Sache, die mir Abt vorgeschlagen hat, muss ich mir auch noch anschauen.

Also vielen Dank noch mal für die tolle Unterstützung.

Grüße Tommylik



Thema: Jede Datei überprüfen - ggf. Dummy Datei erstellen.
Am im Forum: Grundlagen von C#

Hallo Abt,

Vielen Dank für deine Antwort und die Kritik.

Zitat
Also Deine ungarischen Notation tut in den Augen echt weh, da muss man Palladin recht geben...

Ich habe von Palladin die Links bekommen und werde mich um eine korrekte Notation kümmern,
wenn der Ablauf funktioniert.

Zitat
Immer, ausnahmslos immer. Siehe auch die Doku zu Path.Combine.


Wenn ich Path.Combine benutze, werden die Pfadseparatoren automatisch gesetzt.
Mit der Variable strFolder ist das kein Problem, weil diese Variable einen Ordner darstellt.


File.CreateText(Path.Combine("D:\S7_Export\AppData\" , strFolder , strDummy[i])

aber

Die Variable strFile_IB ist ein Teil des Dateinamen und steht am Anfang und der wichtigste Teil vom Dateinamen.
Hier bekomme ich mit Path.Combine einen Pfadseparator in den Dateinamen. Siehe Foto


 prüfen = Directory.GetFiles(Path.Combine(SourcePath, strFile_IB, strZusatz));

Da ich es vorher nicht wusste, muss ich nach einer neuen Lösung suchen.
Zitat
z.B. den Datei-Namen kannst Du damit nicht zusammenbauen.

Danke an Palladin.

Ich habe es mit String.Concat probiert den Dateinamen zusammenzubauen?

Bekomme aber wie vorher den Fehler: System.IO.IOException: "Der Verzeichnisname ist ungültig.
Siehe Foto.
Zitat
Schau Dir doch wenigstens an, was die Methoden und Co tun, wenn Du sie verwendest.

Versuche ich.
Ich bin nie auf den Gedanken gekommen auf eine Klasse oder Methode mal die F1 Taste zu drücken.
Da kommt man ja gleich zu dem, was man braucht. Entwicklertools, technische Dokumentation und Codebeispiele
Zitat
[Artikel] Debugger: Wie verwende ich den von Visual Studio?

Bin fleißig am Nutzen. Siehe Fotos
Vor allem, was VS alles so kann, was ich nicht wusste.

@ Palladin007

Vielen Dank für deine Codebeispiele.
Zitat
Es lohnt, immer mal wieder in die Doku zu schauen, was eine Klasse noch so alles kann.

Das hast du absolut recht. Mir fällt es nur schwer aus den Beispielen, die da mit angegeben sind die richtigen Schlüsse raus zu ziehen.
Sehr oft ist es so das die Beispiele nicht zu dem passt, was du gerade machst. Und dann wechsle ich schnell zu Google.

Ich werde weiter Google bemühen, um die Lösung für den Dateinamen zu finden.

Vielen Dank für Eure Unterstützung.

Tommylik

Thema: Jede Datei überprüfen - ggf. Dummy Datei erstellen.
Am im Forum: Grundlagen von C#

Hallo Palladin007,

Vielen Dank für deine schnelle Antwort.

Zitat
Du solltest Path.Combine nutzen, um Teil-Pfade zusammenzusetzen.

Meinst du so und nur bei strZusatz oder generel?


            string Job1 = "_x015id02xa1_Job1_";
            string Job2 = "_x015id02xa1_Job2_";
            string Job3 = "_x015id02xa1_Job3_";
            string Job4 = "_x015id02xa1_Job4_";
            string Job5 = "_x015id02xa1_Job5_";
            string Job6 = "_x015id02xa1_Job6_";
            string ext = "*.*";

            string[] strZusatz = new string[6];

            strZusatz[0] = Path.Combine(Job1, ext);
            strZusatz[1] = Path.Combine(Job2, ext);
            strZusatz[2] = Path.Combine(Job3, ext);
            strZusatz[3] = Path.Combine(Job4, ext);
            strZusatz[4] = Path.Combine(Job5, ext);
            strZusatz[5] = Path.Combine(Job6, ext);
Zitat
Und bedenke, dass File.CreateText (und andere ähnliche Methoden auch) die Datei öffnet, aber nicht schließt, das musst Du selber machen.

Das habe ich wie folgt abgeändert.


                    using (StreamWriter myWriter = File.CreateText(@"D:\S7_Export\AppData\" + strFolder + strDummy[i]))
                    {
                        myWriter.Close();
                    }
Zitat
Und dein Fehler liegt nicht bei der for-Schleife, dennoch:

Habe ich mir angeschaut und abgeändert.


for (int i = 0; i < strZusatz.Length; i++)

Das mit mit dem strDummy habe ich danach auch gesehen aber daran liegt es auch nicht.
Die For Schleife ist es auch nicht mehr.

Ich habe jetzt ein neues Problem.
Der neue Fehler stoppt jetzt hier:


string[] path;

Der Hinweis lautet:
System.ArgumentException: "Illegales Zeichen im Pfad."

Wenn ich dann mit F10 oder F11 debugge und an diese Stelle komme:


  string[] strZusatz = new string[6];

            strZusatz[0] = Path.Combine(Job1, ext);

Dann steht im strZusatz[0] folgendes: {string[6]}

Ich verstehe es so das die geschweifte Klammer das illegale Zeichen ist.

Und das mein String Array ein Schrotthaufen ist.
Das kommt davon wenn man es nicht richtig versteht und etwas 1 zu 1 umsetzen will.

Wer kann mir sagen wie ich es besser machen könnte.

MfG Tommylik

Thema: Jede Datei überprüfen - ggf. Dummy Datei erstellen.
Am im Forum: Grundlagen von C#


Servus,

Habe eine Form mit einem Button und möchte bei Betätigung
das im vorgegebenen Ordner geprüft wird das alle Dateien vorhanden sind.
Sollte eine oder mehrere Dateien fehlen, sollen dafür Dummy Dateien erstellt werden.


private void button1_Click(object sender, EventArgs e)
        {
            // Nur für eine bessere Verständnis habe ich hier Zahlen hingeschrieben und keine Variablen.
            string strFile = "21050612325";
            string strFolder = "21050612325";        
          
            string TargetPath = @"D:\S7_Export\AppData\" + strFolder;

            string[] strZusatz = new string[6];

            strZusatz[0] = "_x015id02xa1_Job1_" + "*.*";
            strZusatz[1] = "_x015id02xa1_Job2_" + "*.*";
            strZusatz[2] = "_x015id02xa1_Job3_" + "*.*";
            strZusatz[3] = "_x015id02xa1_Job4_" + "*.*";
            strZusatz[4] = "_x015id02xa1_Job5_" + "*.*";
            strZusatz[5] = "_x015id02xa1_Job6_" + "*.*";

            string[] strDummy = new string[6];
            strDummy[1] = "15id02_Job1_Dummy.txt";
            strDummy[2] = "15id02_Job2_Dummy.txt";
            strDummy[3] = "15id02_Job3_Dummy.txt";
            strDummy[4] = "15id02_Job4_Dummy.txt";
            strDummy[5] = "15id02_Job5_Dummy.txt";
            strDummy[6] = "15id02_Job6_Dummy.txt";

            for (int i = 0; i == strZusatz.Length; i++)
            {
                    string path = @"D:\S7_Export\Sensopart\x015id02xa1\" + strFile + strZusatz[i];
                    string[] prüfen;
                    prüfen = Directory.GetFiles(path);
                if (prüfen.Length > 0)
                {
                    Directory.Move(@"D:\S7_Export\Sensopart\x015id02xa1\" + strFile + strZusatz[i], TargetPath);
                }
                else
                {
                    //Dummydatei im Zielordner erstellen

                    StreamWriter myWriter = File.CreateText(@"D:\S7_Export\AppData\" + strFolder + strDummy[i]);
                }                   
                    
            }
            
        }

Wenn ich den Code ausprobiere bekomme ich einen Fehler:
System.IndexOutOfRangeException: "Der Index war außerhalb des Arraybereichs."
Es wird die For Schleife markiert.


Als Vorlage dient mein VBA Code der in einer Runtime einer Visualisierungssoftware läuft.

    Dim strZusatz1(1 To 6) As String
    strZusatz1(1) = "_x015id02xa1_Job1_" & "*.*"
    strZusatz1(2) = "_x015id02xa1_Job2_" & "*.*"
    strZusatz1(3) = "_x015id02xa1_Job3_" & "*.*"
    strZusatz1(4) = "_x015id02xa1_Job4_" & "*.*"
    strZusatz1(5) = "_x015id02xa1_Job5_" & "*.*"
    strZusatz1(6) = "_x015id02xa1_Job6_" & "*.*"

    Dim strDummy1(1 To 6) As String
    strDummy1(1) = "15id02_Job1_Dummy.txt"
    strDummy1(2) = "15id02_Job2_Dummy.txt"
    strDummy1(3) = "15id02_Job3_Dummy.txt"
    strDummy1(4) = "15id02_Job4_Dummy.txt"
    strDummy1(5) = "15id02_Job5_Dummy.txt"
    strDummy1(6) = "15id02_Job6_Dummy.txt"

    qCount = 0
    rCount = 0
    For qCount = 1 To 6
        'check if the file exists
        If Dir("D:\S7_Export\Sensopart\x015id02xa1\" & strFile & strZusatz1(qCount)) <> "" Then
            'Dateien in den Zielordner verschieben
            oFSO.MoveFile "D:\S7_Export\Sensopart\x015id02xa1\" & strFile & strZusatz1(qCount), strTargetPath
            If qCount = 6 Then
                MsgBox "Fertig", vbOKOnly 
            End If
        Else
            rCount = rCount + 1
            'Dummydatei im Zielordner erstellen
            oFSO.CreateTextFile "D:\S7_Export\AppData\" & strFolder & "\" & strDummy1(qCount)
            If rCount = 1 Then
                MsgBox "Es fehlen Dateien. Siehe im Ordner welche", vbExclamation
            End If
        End If
    Next qCount

Könnte mir einer von Euch sagen was falsch ist stehe total auf dem Schlauch.
Ich möchte etwas Umsetzen was es hier im Forum nicht als Beispiel gibt.
Und logischerweise ist alles verschieden zwischen den Sprachen.

Vielen Dank im voraus.

MfG Tommylik



Thema: Wie kann ich ein VBA Skript in C# migrieren?
Am im Forum: Grundlagen von C#

Hallo Abt,

Das ist mir auch klar, aber gegen eine höffliche bitte weil ich etwas nicht kann sollte nichts dagegen sprechen. Und wenn dann jemand freiwillig hilft sollte das auch in Ordnung sein.
Wenn niemand auf meine Bitte reagiert dann habe ich noch die Möglichkeit wie du gesagt hast.
Da aber so etwas ein paar Hundert Euro kostet kommt das für mich nicht in Frage.
Und niemand macht so etwas für 10€.

@ Thomas
Vielen Dank nochmal für deine Hilfe.

Wir können dieses Thema hiermit schließen.

Mfg Tommylik