Try und Catch. Wo Anfang und wo Ende?

[F60.2]

Habe hier folgendes Programm und an makierte Stelle, soll das try beginnen, aber wie muss der Rest aussehen:

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

        private void label1_Click(object sender, EventArgs e)
        {
            label1.Text = "Zum kopieren Button drücken.";
        }

        private void button1_Click_1(object sender, EventArgs e)
        {
            //Pfade definieren
            
//  ##########################################################        
//                       HIER SOLL DER TRY BEGINNEN
// ##########################################################

                string Alt = @textBox2.Text;
                string Neu = @textBox1.Text;
            
            //Array der Dateien
            string[] allesAlt = System.IO.Directory.GetFiles(Alt);
            //solange i kleiner ist als die Anzahl der Dateien, Vorgang wiederholen
            for (int i = 0; i < allesAlt.Length; i++)
            {
                // 
                string olds = System.IO.Path.Combine(Alt, System.IO.Path.GetFileName(allesAlt[i]));
                string news = System.IO.Path.Combine(Neu, System.IO.Path.GetFileName(allesAlt[i]));
                if (olds != news)
                {

                    try
                    {
                        //Dateien kopieren
                        statusliste.Items.Add(news);
                        System.IO.File.Copy(olds, news);
                        
                    }

                    catch (System.IO.DirectoryNotFoundException a)
                    {
                        System.IO.Directory.CreateDirectory(Neu);
                        System.IO.File.Copy(olds, news, true);

                        //Console.WriteLine(a.Message);
                        //MessageBox.Show("Kopieren fehlgeschlagen!");

                    }
                    catch (System.IO.FileNotFoundException a)
                    {
                        Console.WriteLine(a.Message);
                        MessageBox.Show("Datei nicht gefunden");
                    }
                    catch (ArgumentException a)
                    {
                        Console.WriteLine(a.Message);
                        MessageBox.Show("Ziel- /Quellverzeichnis nicht gefunden");
                    }
                    catch (System.IO.IOException a)
                    {
                        System.IO.File.Copy(olds, news, true);
                        //Console.WriteLine(a.Message);
                        //MessageBox.Show("It's Not a Bug, It's a Feature!");
                    }


                }
                
            }

            MessageBox.Show("Übertragung abgeschlossen.");
        }



        private void button2_Click(object sender, EventArgs e)
        {
            //Anwendung schließen
            Application.Exit();
        }

        private void button3_Click(object sender, EventArgs e)
        {
            label2.Text = textBox1.Text;
        }
        }
    }

Danke bereits vorweg

Gruß
F60.2

[Ralf Jansen]

Das hängt davon was du für Exceptions in dem Code dazwischen fangen willst. Ein allgemein richtige Stelle gibt es nicht.

[Jürgen Thomas]

Hallo,

ich würde try-catch lassen, wo es jetzt steht. Die Fehler können bei jeder einzelnen Datei auftreten; der Rest ist eigentlich "sicher" vor Fehlern.

Nur die DirectoryNotFoundException gefällt mir überhaupt nicht. Mach daraus lieber eine if-Abfrage; wenn es noch nicht existiert, dann erzeuge es (und zwar vor dem try). Wenn diese Exception dennoch auftritt, kann es keine Ersatzmaßnahme geben; dann ist entweder der Name völlig falsch, oder man hat keine Rechte. Beides ist gravierend und nicht durch Create+Copy zu steuern.

Nebenbei:
1. Der Kommentar zu for ist überflüssig; das genau steht in for drin.
2. Was soll der @ bei textBox2.Text? Der hat nur eine Bedeutung für String-Konstante, aber nicht für String-Variable oder String-Eigenschaften.
3. Namen wie textBox2 oder Label17 gehören verboten, siehe .NET Richtlinien für Namen
4. Wenn du using benutzt, brauchst du nicht so lange Romane zu schreiben; die ständige Wiederholung von "System.IO" wird langweilig.

Gruß Jürgen

[F60.2]

Danke,
soweit ist das angekommen.

Mach daraus lieber eine if-Abfrage; wenn es noch nicht existiert, dann erzeuge es (und zwar vor dem try).

Ist so gesehen keine schlechte Idee, aber wenn kein Verzeichniss im Pfad steht, kann er kein Verzeichniss erstellen.
Wenn ich jedoch das try über die Pfadabfrage packe kennt der eine Menge strings nicht mehr. Aber wie dann?
Hab hier noch ne Frage die hier als Beispiellösung dienen könnte.

[da_halbi]

außerdem würde ich die zeile

statusliste.Items.Add(news);

nach

System.IO.File.Copy(olds, news);

ausführen.

ansonsten würde bei einem kopierfehler die eigentlich nicht kopierte datei trotzdem in deiner liste stehen und das ist ja nicht deine absicht oder?

[F60.2]

Stimmt, danke.
So hab das Problem nun eigenständig lösen können.

Danke nochmal an alle

Gruß
F60.2

[fanderlf]

Wäre schön wenn Du Deine Lösung noch posten würdest, damit alle etwas davon haben

Danke!

[_CISS_]

Wie siehts mit der Lösung (Code) aus?

[F60.2]

Schuldigung das ich erst so spät damit rausrücke, aber wie man sieht hat sich einiges an meinem Code geändert.

Wer jetzt denkt der Code funktioniert jetzt einfahc so wenn man ihn hier kopiert, sollte wissen das ich eioniger unwichtige Sachen weg gelassen habe.

Peace

namespace Copyme
{
    public partial class Form1 : Form
    {
        public Form1()
        {
            InitializeComponent();
        }
        //###########################################################
        // Copybutton
        //###########################################################
        
        
        private void copybutton_Click_1(object sender, EventArgs e)
        {
            statusliste.Items.Clear();
            //Pfade definieren
            string Alt = @textBox1.Text;
            string Neu = @textBox2.Text;

            //Overwrithe
            bool overW = false;
           
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
//                 Try                      
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
            try
            {
                //Dateiliste
                string[] olddatalist = System.IO.Directory.GetFiles(Alt);
                string[] allesAltFolder = System.IO.Directory.GetDirectories(Alt);

//XXX*** Überschreiben an/aus ***XXX
                if (schreibcheck.Checked == true)
                {
                    overW = true;
                }
                else
                {
                    overW = false;
                }
                //Liste der Dateien im Hauptordner als Arrays
                for (int i = 0; i < olddatalist.Length; i++)
                { 
                      string olds = System.IO.Path.Combine(Alt, System.IO.Path.GetFileName(olddatalist[i]));
                      string news = System.IO.Path.Combine(Neu, System.IO.Path.GetFileName(olddatalist[i]));
                    
//XXX*** Unterordner mitkopieren ***XXX
                    if (ordnercheck.Checked == true)
                    {
                        //Ordner nach inhalt durchsuchen 
                        DirectoryInfo di = new DirectoryInfo(Alt);
                        //
                        FileInfo[] fi = di.GetFiles();
                        // Dateien Kopieren
                        foreach (FileInfo file in fi)
                        {
                            file.CopyTo(Path.Combine(Neu, file.Name), overW);
                            string[] myList = new string[1];
                            myList[0] = "OK   |   " + Neu + @"\" + file.Name;
                            statusliste.Items.AddRange(myList);
                        }
                        // Nach Unterordnern suchen
                        DirectoryInfo[] di2 = di.GetDirectories();
                        foreach (DirectoryInfo directory in di2)
                        {
                            // Unterordner Kopieren
                            string sPath = Neu + @"\" + directory.Name;
                            UnterOrdnerCopy(directory, sPath);
                            string[] myList = new string[1];
                            myList[0] = "OK   |   " + sPath + " || Unterordner kopiert";
                            statusliste.Items.AddRange(myList);
                        }
                    }
//XXX*** Normalverfahren ***XXX
                    else
                    {
                        System.IO.File.Copy(olds, news, overW);
                        string[] myList = new string[1];
                        myList[0] = "OK   |   " + news;
                        statusliste.Items.AddRange(myList);  
                    }
//-----------------------------------------------------------------
                // Ergebniss
//-----------------------------------------------------------------
                
            }
                statusliste.Items.Add("Es wurden " + statusliste.Items.Count + " Objekte kopiert.");
                MessageBox.Show("Übertragung beendet.");
        }
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
                // Catch
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
            catch (System.IO.DirectoryNotFoundException a)
            {
                Console.WriteLine(a.Message);
                statusliste.Items.Add("Kopieren fehlgeschlagen!");
                statusliste.Items.Add("Überprüfen sie ob alle Pfade wirklich existieren.");
            }
            catch (System.IO.FileNotFoundException a)
            {
                Console.WriteLine(a.Message);
                statusliste.Items.Add("Keine Dateien gefunden.");
            }
            catch (ArgumentException a)
            {
                Console.WriteLine(a.Message);
                statusliste.Items.Add("Ziel- /Quellverzeichnis nicht gefunden.");
            }
            catch (System.IO.IOException a)
            {
                Console.WriteLine(a.Message);
                statusliste.Items.Add("Datei bereits vorhanden oder schreibgeschützt.");
            }
           
            catch (Exception a)
            {
                Console.WriteLine(a.Message);
                statusliste.Items.Add("Fatal Error!");
            }
        }

[fanderlf]

geht das wirklich oO

string Alt = @textBox1.Text;
string Neu = @textBox2.Text;

find ich igendwie spannend

[Jürgen Thomas]

@fanderlf
Wenn du dich auf das '@' beziehst: Der Compiler ignoriert es offensichtlich. Mir ist aber auch schleierhaft, wieso viele Anfänger den Unterschied zwischen einer Konstanten (Stringliteral) und einer Variablen nicht verstehen.

@F60.2
Merke: @ ist nützlich bei String-Konstanten. Es ist überflüssiger Quatsch bei String-Variablen!

Jürgen

[F60.2]

@Jürgen Thomas
Ja ich bin Anfänger und zwar blutiger.

@fanderlf
Suprise Suprise,
ja das geht wirklich und solange es geht juckt mich das auch nicht wirklich.
dafür hab ich andere probleme

[fanderlf]

@fanderlf
Suprise Suprise,
ja das geht wirklich und solange es geht juckt mich das auch nicht wirklich.
dafür hab ich andere probleme

Das ist keine gute Einstellung. Damit kommt man über kurz oder lang in Teufels Küche. Versuch doch wenigstens nocmal nachzulesen worum es sich beim @-Operator handelt und warum er vor einem Variablennamen keinen Sinn macht.

Wir haben hier auch lange Zeit nach dem Motto programmiert:

Hauptsache es funktioniert!

Langfristig tut man sich damit leider selbst keinen Gefallen, aber das sieht man momentan natürlich nicht. Meistens muss mans leider auch erst auf die harte Tour lernen