Du könntest das Event CellFormatting deines DGV registrieren, welches immer aufgerufen wird, wenn die Inhalte einer Zelle formatiert werden müssen. Dort könntest du dann in etwa so reagieren:

if (dgv[e.RowIndex, e.ColumnIndex].Value == "deine Bedingung")
{
    dgv[e.RowIndex, e.ColumnIndex].Style.BackColor = Color.Red;
}

PS: Das Ganze ist ungetestet, sollte aber in etwa so hinhauen

Hier noch ein Screen der Beispielanwendung:

Beschreibung:

Ich bin vor einiger Zeit über das Hindernis gestoßen, dass man im .NET Framework nur Dateien mit System.IO.File.Copy() als ein Ganzes kopieren kann. Möchte man nun z.B. eine große Datei kopieren, hat man keine Möglichkeit den Fortschritt des Kopiervorgangs auf der GUI, etwa durch eine Prozessbar, sichtbar zu machen.

Dieses Manko wollte ich beheben und hab mich dazu entschlossen eine Klasse zu schreiben, die Dateien binär kopiert und während dieses Vorgangs einen Fortschritt berechnet. Um das Ganze zu komplettieren habe ich auch gleich die Berechnung des Datendurchsatzes und der Restzeit des Kopiervorgangs mit eingebaut.

Um die Funktionalität nicht nur auf eine einzelne zu kopierende Datei zu beschränken, bietet die Klasse auch die Möglichkeit eine Liste von Dateien zu übergeben in Form einer System.Collections.Generic.List<string>, eines string[] Arrays oder eines System.IO.FileInfo[] Arrays. Die Klasse informiert dann während des Kopierens über den prozentualen Fortschritt der Dateiliste, der aktuell zu kopierenden Datei und bezogen auf die Datei die grad kopiert wird ebenfalls Fortschritt in Prozent, Datendurchsatz und Restzeit. Auf diese Weise ließe sich eine Kopier-Fortschritts-Ansicht erstellen, wie man es z.B. aus dem TotalCommander kennt. Eine Prozessbar für die gesamten zu kopierenden Dateien und eine für den Kopiervorgang der aktuellen Datei.

Die Klasse gibt alle Informationen über den Kopiervorgang per Events nach draußen, welche dann abonniert werden können. Der Komponente liegt eine Beispiel Applikation bei, die die CopyComponent in einem BackgroundWorker verwendet. Die wesentlichen Codestücke zur Verwendung habe ich noch mal hervorgehoben:

// Instanz der BinaryCopiers
BinaryCopy bCopy = new BinaryCopy();

private void backgroundWorker_DoWork(object sender, DoWorkEventArgs e)
{
      // Event des BinaryCopiers registrieren
     bCopy.BinaryCopyEvent += new BinaryCopyEventHandler(bCopy_BinaryCopyEvent);
     // Kopie der Datei starten
     bCopy.Copy(tbSource.Text, tbDestination.Text, true);
}

void bCopy_BinaryCopyEvent(object sender, BinaryCopyEventArgs e)
{
     // Auf das BinaryCopy Event reagieren und beim BGW das ProgressChanged Event auslösen und die BinaryCopyEventArgs übergeben
      backgroundWorker.ReportProgress(e.Percent, (object)e);
}

private void backgroundWorker_ProgressChanged(object sender, ProgressChangedEventArgs e)
{
       // EventArgs abfragen
       BinaryCopyEventArgs binaryArgs = (e.UserState as BinaryCopyEventArgs);
       // Prozessbar aktualisiern
       tsProgressBar.Value = e.ProgressPercentage;
       // Datendurchsatz in einem Label anzeigen
       tsslRate.Text = binaryArgs.KbPSec.ToString("N").Substring(0, binaryArgs.KbPSec.ToString("N").Length - 3) + " Kb/sec"; 
       // Restzeit in einem Label anzeigen
       tsslRemaning.Text = binaryArgs.Remaning.ToString();
}

Die Klasse mit der Beispielanwendung befindet sich im Anhang. Für Korrekturen (auch am Stil) und Verbesserungsvorschläge bin ich natürlich offen.

UPDATE vom 11.10.2010 (Datei-Downloads vor Update: 229):

• Verbesserungsvorschläge von Abt übernommen (siehe Postings weiter unten)
• Eine Methode zum kopieren ganzer Ordner samt Inhalt hinzugefügt

UPDATE vom 26.03.2014 (Datei-Downloads vor Update: 459):

• Verbessertes kopieren von Ordnern, welches nun auch per Event über den Fortschritt des kopierens eines ganzen Ordners informiert.
• Sample App auf die Veränderung angepasst

Schlagwörter: kopieren, Daten kopieren, Datei kopieren, Dateien kopieren, Restzeit, Datendurchsatz, Prozessfortschritt

Hast du in deiner Hauptform die Eigenschaft KeyPreview auf True gesetzt?

Danke für die Tipps! Ich werde mir Mantis mal als erstes näher anschauen, klingt nach dem was ich suche. Da ich nach ner einfachen Lösung ohne viel Schnick Schnack suche, werde ich auch Redmine mal begutachten.

Hallo zusammen,

ich suche zur Zeit nach einem kostenlosen, nach Möglichkeit webbasierten, Bugtracker. Habt ihr vielleicht Empfehlungen, mit denen ihr glücklich seid?

Die Anforderung ist eigentlich recht simpel: Zu verschiedenen Projekten sollen auf einfache weise Bugs und Feature Wünsche eingetragen werden können. Das Ganze sollte einigermaßen ergonomisch und bedienerfreundlich sein.

Ich bin gespannt...

dataGridView1.CurrentCell = dataGridView1[1, 0];
dataGridView1.BeginEdit(true);

Ich weiß zwar nicht ob oder wie man einen Dialog per Dienst öffnet, aber was spricht gegen eine Applikation, die im System Tray verschwindet wenn sie minimiert ist? Im Prinzip sowas wie man es vom Windows Messenger kennt. So eine Applikation kann in jedem Fall ein neues Fenster öffnen.

Hallo Khalid,

danke für deine Antwort. Ich bin gespannt auf eine neue Version, bis es soweit ist werde ich mir das auch nochmal näher anschauen und anhand deiner Tipps gucken, ob ich selber schon was implementieren kann.
Btw: Den Vorschlag der es "Back"-Buttons von TBR finde ich auch sehr interessant.

Setze mal den Eigenschaftswert "Orientation" auf Vertical. Dann sollte es gehen.

Wenn es rein um die strukturelle Ordnung geht könntest du deine Klasse in eine partial class aufteilen und wie talla schon sagte regions einsetzen, um z.B. logisch zusammengehörige Methoden, Events, etc. zusammenzufassen. Diese beiden Möglichkeiten räumen den Quellcode schon gewaltig auf.

IronPython hab ich noch nciht ausprobiert. Bin aber vom klassischen Python absolut begeistert und stellt auch bei mir eine Alternative (z.B. bei Consolenanwendungen) zu manchen .NET Applikationen dar.

Nur so als Tipp: Solltest du nicht gerade von einem großen Raid aus die Kopie starten, dann sollten wenige bzw. nur ein Thread die beste Performance liefern. Ansonsten muss der Lesekopf der Festplatte zu viel hin und her springen, was die Datenrate gewaltig drücken kann.

Ich kann den Film "Sieben Leben" mit Will Smith wärmstens empfehlen.

Escape das "A" mal mit nem Backslash z.B. in der From: "90-\A-00", dann sollte es gehen.

Hallo Khalid,

ich hab mal wieder Fragen zum Win Explorer. Ich würde gerne ein paar neue Features implementieren die da wären (im ShellListView):

• kopieren + einfügen (per Kontextmenü und den Shortcuts Strg + C / Strg + V)
• auschneiden + einfügen (per Kontextmenü und den Shortcuts Strg + X / Strg + V)
• Die Funktion eine Datei innerhalb eines Ordners per Drag & Drop bei gedrückter Strg-Taste zu kopieren
• Drag & Drop Funktion vom echten Win Explorer hin zum ShellListView

Kannst du mir zu den Punkten ein paar Tipps geben, wie die sich einfach realisieren ließen? Soweit ich das erkennen konnte, ist die Behandlung der ersten beiden Punkte zwar im Quellcode in den Enums berücksichtigt worden, wurde von dir aber nicht implementiert. Hatte das einen Grund?

Hast du denn den 3 GB Switch in der Boot.ini gesetzt?
edit: @GarlandGreene: Nein, das geht auch mit nem normalen XP. Es stehen dann 3,5 GB zur Verfügung.

Ansonsten einfach im Oktober auf win 7 umsteigen und das Problem erübrigt sich ;o)

Edit2:

So sieht meine Boot.ini aus. Einmal der 3GB Switch und einmal der normale Modus:

[boot loader]
timeout=5
default=multi(0)disk(0)rdisk(0)partition(1)\WINDOWS
[operating systems]
multi(0)disk(0)rdisk(0)partition(1)\WINDOWS="Microsoft Windows XP Professional / 3 GB" /noexecute=optin /fastdetect /3GB
multi(0)disk(0)rdisk(0)partition(1)\WINDOWS="Microsoft Windows XP Professional" /noexecute=optin /fastdetect

Ich habe so etwas ähnliches mal mit PdfSharp realisiert. Ist aber schon etwas aufwändiger, da alles "von Hand" formatiert wurde.

Ich hab hier nochmal einen sehr lesenswerten Artikel zu Micorsoft und Windows 7

http://www.spiegel.de/spiegel/0,1518,634334,00.html

Zum Beispiel die Tatsache, dass Microsoft nach Vista komplett auf Pair-Programming umgestiegen ist finde ich spannend...

als cpu nen intel i7, der 920er reicht aus und ließe sich auch wunderbar übertakten
http://geizhals.at/deutschland/a366185.html

als graka ne geforce 280
http://geizhals.at/deutschland/a344408.html

arbeitsspreicher natürlich den schnellen ddr3, die neuen intel i7 unterstützen zudem triple channel

Ich glaub es wurde noch nicht erwähnt: Meines Wissens wird Win 7 zwar ohne vorinstallierten IE ausgeliefert, es soll aber eine CD beiliegen auf der sich der IE befindet. Das bedeutet zwar extra Aufwand, ist aber meiner Meinung nach okay.

Ich kann mich an etliche Diskussionen, noch vor ein paar Jahren erinnern, die unbedingt forderten, dass man den IE deinstallieren können sollte. Nun gehts und jeder kann selbst entscheiden was er nutzt. Ich finds gut!

Aso, ok. Ich hatte mich nur gewundert, weil man auf den Screenshots die Arbeitszeiten sah und von 8-18 Uhr sind 10 Std und nicht 9. Daher dachte ich, die es würde pauschal ne Std abgezogen werden, für die Pause.

Und wie loggst du die Pausen? Ziehst du pauschal ne Stunde ab? Was ja zu Fehlern führen kann, bzw. nicht korrekt ist, wenn durchgearbeitet wurde. Ich würde den PC auf Inaktivität prüfen, um dann ne Auswahl zur Verfügung zu Stellen, was in der Zeit gemacht wurde (Pause, Meeting, Arbeit, etc.)

In den Snippets hatte ich mal folgende kleine Klasse veröffentlicht:

LogFileWriter mit Multithreaded Unterstützung als Singelton implementiert

Das von dir gewünschte Zusatzverhalten sollte ohne Probleme zu implementieren sein. Könntest ja deine Modifikation dann auch veröffentlichen.

naja... bei einem stack würde es bedeuten, das die ersten die kommen, bei entsprechender auslastung, niemals (oder nur extrem spät) abgearbeitet werden.

Wieso? Die System.Collections.Generic.Queue ist ein FIFO Stack.

Wow, also das auch in der Softwarebranche so viele betroffen sind hätte ich eigentlich nicht gedacht. [..]

Hatte ich anfangs auch nicht gedacht, aber es ist übler als man glaubt. Noch vor ca 4 Monaten berichtete das Hamburger Abendblatt davon, dass alle Branchen den Bach runter gehen, nur der IT Branche würde es weiterhin bestens gehen. Pustekuchen.
Ich hatte erst vor 2 Monaten ein Treffen mit meinen ehemaligen Mitstudenten (wir haben alle 07 oder 08 abgeschlossen) und das Bild was ich da bekam, war ein ganz anderes. Quer durch die gesamte IT Branche gab es nichts positives zu berichten. Angefangen bei global Playern wie Adobe (in dem besagten Abendblatt Artikel noch als positives Beispiel genannt), über industrielle Größen wie Sharp bis hin zu renomierten deutschen Spielesoftwareschmieden überall das selbe Bild: Aufnahmestopp und teilweise sogar Stellenabbau.

Bitter, wenn man gerade erst in der Branche fußgefasst hat und sich vielleicht weiterentwickeln möchte, indem man verschiedene Jobs ausprobiert. Das wird leider zur Zeit alles sehr schwer...

Zum Beispiel hier:

Mark Rideout's Blog : Customizing the DataGridView to support expanding/collapsing (ala TreeGridView)

Müsste doch auch mit nem Background Worker gehen, der ja standardmäßig beim beenden ein Event feuert. Wenn ich mich nicht irre, lässt sich beim behandeln dieses Complete Events auch auf die GUI zugreifen...

Wirf doch auch mal einen Blick auf

http://www.drupal.de/

SmtpClient client = new SmtpClient("dein server", 25);

MailAddress from = new MailAddress("sender email");
MailAddress to = new MailAddress("empfänger email");

MailMessage message = new MailMessage(from, to);

message.Priority = MailPriority.High;
message.IsBodyHtml = true;
message.ReplyTo = from;

message.Body = "Dein HTML Code";

client.Send(message);

Beschreibung:

Ich habe hier eine kleine Klasse, mit der sich ein einfaches Logging in der eigenen Applikation implementieren lässt. Gerade in Projekten die Multithreading verwenden, wird das Debuggen sehr schwer und es bietet sich an, gewisse Aktionen im Programmablauf einfach in ein Logfile zu schreiben, oder auf diese Weise Exceptions mitzuloggen.

Die Klasse ist nach dem Singelton Entwurfsmuster implementiert.

namespace LogFileWriter
{
    /// <summary>
    /// Klasse zum schreiben eines LogFiles, mit Multithreaded Unterstützung.
    /// </summary>
    public class LogWriter
    {
        private static LogWriter instance;
        private static object syncLock = new object();

        private string _logName = Environment.CurrentDirectory + @"\log\logfile.txt";

        public static LogWriter GetInstance()
        {
            // Multithreaded Support 
            if (instance == null)
            {
                lock (syncLock)
                {
                    if (instance == null)
                    {
                        instance = new LogWriter();
                    }
                }
            }

            return instance;
        }

        private LogWriter()
        {
        }

        /// <summary>
        /// Loggt eine Exception
        /// </summary>
        /// <param name="exception"></param>
        public void LogException(Exception exception)
        {
            string msg = exception.Message + " (" + exception.Source + ")";
            LogMessage(msg, "Fehler");
        }

        /// <summary>
        /// Schreibt eine Nachricht ins Logfile
        /// </summary>
        /// <param name="message">Die zu loggende Nachricht</param>
        /// <param name="severity">Nachrichtenkategorie (z.B. Info, Fehler, etc.)</param>
        public void LogMessage(string message, string severity)
        {
            string body = DateTime.Now.ToString("HH:mm:ss")
                + " - "
                + severity
                + ":"
                + Environment.NewLine + message;

            if (!Directory.Exists(Path.GetDirectoryName(_logName)))
            {
                Directory.CreateDirectory(Path.GetDirectoryName(_logName));
            }

            if (!File.Exists(_logName))
            {
                body = "Logfile erstellt am "
                    + DateTime.Now.ToShortDateString()
                    + " um "
                    + DateTime.Now.ToShortTimeString()
                    + Environment.NewLine
                    + Environment.NewLine
                    + body;
            }

            try
            {
                using (StreamWriter sw = new StreamWriter(_logName, true))
                {
                    sw.WriteLine(body);
                }
            }
            catch (Exception e)
            {
                throw e;
            }
        }
    }
}

Schlagwörter: File Logging, Logfile, Singleton, Multithreading, LogWriter, überwachung

Versuch es in deiner Einfüge Schleife doch mal so:

foreach (string dll in files)
                {
                    string df = Path.GetFileName(dll);
                    lv_dll.Items.Add(df); 
                }

Sehr gut. Damit klappt es bestens. Gut möglich, dass ich in Zukunft nochmal ähnliche Fragen stellen werde. Dank dir soweit.

Hallo Khalid,

wie ich ja schon schrieb nutze ich deine alte Version des Win Explorers. Mir ist aufgefallen, dass wenn ich die Detail Ansicht des ShellListViews anwähle, die Dateien mit einer falschen "geändert am" Zeit angezeigt werden. Die Zeit wird immer 2 Stunden früher angezeigt, also 8:00 Uhr statt 10:00 Uhr.
Ich muss zugeben ich habe nach dem Bug noch nicht gesucht, in der Hoffnung, dass dir dazu sofort was einfällt. Ist das nicht der Fall, suche ich natürlich selber nach dem Fehler ;o)

Ich war von deiner alten Win Explorer Komponente schon extrem begeistert und hatte die schon verwendet. Ich werde nun bei Gelegenheit deine neue Version mal unter die Lupe nehmen. Bisher klasse Arbeit!

In unserem Studio wird für 2D überwiegend "Toon Boom" eingesetzt. 3D wird u.a. mit "Motion Builder" bearbeitet. Die Programme sind für die professionelle Anwendung, daher auch nicht unbedingt billig. Ob es vergleichbares als Freeware gibt, dass weiß ich nicht.

direkter vergleich mit google:

>

Schonmal sehr interessant der Artikel. Ich freue mich schon auf die ersten eigenen Tests, lange dauert es ja nicht mehr. Ich glaube gerade als Entwickler kann es Hilfreich sein damit zu suchen. Mal gucken was die Maschine ausspuckt, wenn man eingibt "Warum flackert meine GUI?" ;o)

Im übrigen finde ich das Design sehr gelungen. Schön schlicht.

http://www.wolframalpha.com/

Ungefähr so sollte es gehen...

using System.IO;

            DirectoryInfo di = new DirectoryInfo(@"C:\test");
            FileInfo files = di.GetFiles("*", SearchOption.AllDirectories);

            // Prozessbar mit files.Count initialisieren

            foreach (FileInfo fi in files)
            {
                fi.CopyTo(@"C:\test2\" + fi.Name, true);

                // Prozessbar incrementieren
            }

Ich finde man kann auch Serien als "must-see" empfehlen. Da wäre bei mir an aller erster Stelle LOST - einfach obergenial diese Serie, mit einem unglaublichen Suchtfaktor - und an zweiter PRISON BREAK.

In meinen Augen sind diese Vorgaben auch äußerst unsinnig. Gerade sowas wie die Klammerung soll ja die Lesbarkeit fördern, was mit deinem geposteten Beispiel m.E. nach verfehlt wird.

Methoden müssen kurz sein, nur eine Aufgabe erfüllen und dabei komplett auf dem Bildschirm platz finden.
Der Standard ist bei max. 10 Zeilen

So eine ähnliche Vorgabe hatten sie uns in der Uni auch mal gegeben. Allerdings war es bei uns großzügiger bemessen. Da hieß es eine Methode sollte nicht länger als ein Bildschirm sein.

Alles im allen finde ich, dass diese Regeln eher hindern, als das sie förderlich sind.

Nutze z.B. die Funktion AddDirectorySecurity um Rechte zu setzen. Der Parameter FileName kann entweder ein File sein, oder auch ein Ordner. Der Parameter Account ist der Domänenname + Benutzername. Ganz unten ist ein Beispielaufruf.

using System.DirectoryServices;
using System.Security.AccessControl;

public void AddDirectorySecurity(string FileName, string Account, FileSystemRights Rights,
                                                InheritanceFlags Inheritance, PropagationFlags Propogation,
                                                AccessControlType ControlType)
        {
            try
            {
                // Create a new DirectoryInfo object. 
                DirectoryInfo dInfo = new DirectoryInfo(FileName);
                // Get a DirectorySecurity object that represents the  
                // current security settings. 
                DirectorySecurity dSecurity = dInfo.GetAccessControl();
                // Add the FileSystemAccessRule to the security settings.  

                dSecurity.AddAccessRule(new FileSystemAccessRule(Account,
                                                                 Rights,
                                                                 Inheritance,
                                                                 Propogation,
                                                                 ControlType));
                // Set the new access settings. 
                dInfo.SetAccessControl(dSecurity);
            }
            catch (System.InvalidOperationException e)
            {
                Console.WriteLine(e.Message);
            }
        }

        // Removes an ACL entry on the specified directory for the specified account. 
        public void RemoveDirectorySecurity(string FileName, string Account, FileSystemRights Rights,
                                                InheritanceFlags Inheritance, PropagationFlags Propogation,
                                                AccessControlType ControlType)
        {
            // Create a new DirectoryInfo object. 
            DirectoryInfo dInfo = new DirectoryInfo(FileName);
            // Get a DirectorySecurity object that represents the  
            // current security settings. 
            DirectorySecurity dSecurity = dInfo.GetAccessControl();
            // Add the FileSystemAccessRule to the security settings.  
            dSecurity.RemoveAccessRule(new FileSystemAccessRule(Account,
                                                             Rights,
                                                             Inheritance,
                                                             Propogation,
                                                             ControlType));
            // Set the new access settings. 
            dInfo.SetAccessControl(dSecurity);
        }

        // Removes an ACL entry on the specified directory for the specified account. 
        public void RemoveInheritablePermissons(string FileName)
        {
            // Create a new DirectoryInfo object. 
            DirectoryInfo dInfo = new DirectoryInfo(FileName);
            // Get a DirectorySecurity object that represents the  
            // current security settings. 
            DirectorySecurity dSecurity = dInfo.GetAccessControl();
            // Add the FileSystemAccessRule to the security settings. 
            const bool IsProtected = true;
            const bool PreserveInheritance = false;
            dSecurity.SetAccessRuleProtection(IsProtected, PreserveInheritance);
            // Set the new access settings. 
            dInfo.SetAccessControl(dSecurity);
        }

Zum Aufrufen

// Leserechte setzen
accessManager.AddDirectorySecurityRecursive(@"C:\test\test.txt", user, FileSystemRights.ReadAndExecute,
                                             InheritanceFlags.ContainerInherit | InheritanceFlags.ObjectInherit,
                                             PropagationFlags.None, AccessControlType.Allow);

// Vollzugriff setzen
accessManager.AddDirectorySecurityRecursive(@"C:\test\test.txt", user, FileSystemRights.ReadAndExecute,
                                             InheritanceFlags.ContainerInherit | InheritanceFlags.ObjectInherit,
                                             PropagationFlags.None, AccessControlType.Allow);

Ich möchte mir eben genau diese Serializer Methode selber schreiben!
Weiß aber nicht wie ich an die Sache rangehe.

Wäre es nicht ne Möglichkeit dir einfach die Serializer Methode mit dem .NET Reflector anzuschauen und daraus die Funktionsweise abzuleiten?

Sobald sich dein Tool heimlich und unbemerkt vom Benutzer auf dem Rechner installiert, hast du eine Schadsoftware programmiert. Das bedeutet du machst dich, wie Jack schon sagt, strafbar.

Lass es lieber sein.

Wenn es nur um den Anmeldenamen geht dann sollte doch folgender Befehl ausreichen:

Environment.UserName

ich nutze das oft so:

string mail = Environment.UserName + "firmenname.de"

Ich würde das ganze wohl über casts lösen. Dabei kommst du in der Tat nicht um die von dir schon erwähnten if-Abfragen herum:

foreach (Control ctrl in ModHost.Controls)
{
    if (crtl is _ucMyControl)
    {
        (crtl as _ucMyControl).spezielles_property_x
    }
    else if (crtl is _ucNochEinControl)
    {
        (crtl as _ucNochEinControl).spezielles_property_y
    }
}