Dateisortierung - nur etwas umständlicher

        public static string[] DistinctPictures(string[] files)
        {
            // Eine Liste, die die Hash-Werte der Bilder gleich auf nimmt,
            // um die Bilder nicht so lange im Speicher zu lassen
            List<byte[]> PictureHashList = new List<byte[]>(files.Length);
            // Durchläuft das Array der Datei-Pfade
            for (int i = 0; i < files.Length; i++)
            {
                // Image.FrimFile(string) liest aus einer Bild-Datei die Daten für ein Image-Objekt
                // Dieses Bild wird als Ressource behandelt, using sorgt dafür,
                // dass der Speicher nachträglich wieder frei gegeben wird
                using (Image img = Image.FromFile(files[i]))
                {
                    // Das Bild wird als byte-Array gespeichert, aus dem dann der SHA256-Hash-Wert berechnet werden kann
                    ImageConverter imgConverter = new ImageConverter();
                    Byte[] ImgBytes = (Byte[])imgConverter.ConvertTo(img, typeof(Byte[]));

                    // Hier wird der SHA256-Hash-Wert berechnet und in die Liste von Oben gelegt
                    SHA256Managed sha = new SHA256Managed();
                    PictureHashList[i] = sha.ComputeHash(ImgBytes);
                } // Dort wo der using-Block endet, wird auch das Bild via Dispose() aus dem Speicher gelöscht
            }

            // Um sicher zu gehen, dass wirklich jeder SHA256-Hash-Wert nur einmal vorhanden ist
            // muss ich alle Anderen aus sortieren, deher lege ich die Werte zusammen mit dem Datei-Pfad
            // in ein Dictionary
            Dictionary<byte[], string> dictionary = new Dictionary<byte[], string>();
            for (int i = 0; i < PictureHashList.Count; i++)
            {
                // Die Liste der Keys benötige ich um eine Alternative zu ContainsKey(byte[]) zu bauen,
                // da diese Methode nicht sequenziell vergleicht
                List<byte[]> Keys = dictionary.Keys.ToList();
                if (!ContainsByteArrayKey(Keys, PictureHashList[i]))
                {
                    // Wenn der neue SHA256-Hash-Wert nicht gefunden wurde, kann er in das Dictionary aufgenommen werden
                    // Gleichzeitig wird noch der Datei-Pfad eingefügt,
                    // damit der im Nachhinein in einem Array zurück gegeben werden kann
                    dictionary.Add(PictureHashList[i], files[i]);
                }
            }
            // Die Dateipfade der nicht doppelten Bilder werden zurück gegeben
            return dictionary.Values.ToArray();
        }

        // Diese Methode stellt die Alternative zu ContainsKey(byte[]) dar,
        // sie benötigt eine Liste der Schlüssel und den neuen Schlüssel, der darin gesucht wird
        // Diese Methode hab ich in der kurzen Fassung als Lambda-Ausdruck geschrieben und
        // mit einem Delegaten gestartet um keine zweite Methode zu benötigen
        private static bool ContainsByteArrayKey(List<byte[]> Keys, byte[] NewKey)
        {
            foreach (var item in Keys)
            {
                // Wenn beim Durchlaufen der Schlüssel nur einmal der neue Schlüssel gefunden wird true zurück gegeben
                // SequenceEqual(byte[]) vergleicht die einzelnen Elemente der Arrays
                if (NewKey.SequenceEqual(item))
                {
                    return true;
                }
            }
            return false;
        }

using System;
using System.Collections.Generic;
using System.Linq;
using System.Security.Cryptography;
using System.Drawing;
using System.IO;

namespace Tools
{
    class Program
    {
        static void Main(string[] args)
        {
            // Empfängt den Pfad des Ordners, in dem die exe-Datei liegt
            string WorkPath = Environment.CurrentDirectory;

            // Hier suche ich einen in jedem Fall nicht vorhandenenen Ordner-Namen
            string ResultPath = WorkPath + "~";
            int i = 1;
            // Die Schleife läuft so lange weiter, bis der abgeänderte Pfad nicht existiert.
            // Damit die Änderung sich auch ändert, wird eine int-Variable hoch gezählt
            while (Directory.Exists(ResultPath + i.ToString())) i++;
            // Wenn die Schleife nun endet, speicher ich den neuen Pfad ab und erstelle den Ordner.
            ResultPath += i.ToString();
            Directory.CreateDirectory(ResultPath);

            // Ruft alle Datei-Pfad im angegebenen Ordner ab
            string[] files = Directory.GetFiles(WorkPath);

            // Hier kommen die ausgemisteten Dateien an, ohne Duplikate
            string[] Results = DistinctPictures(files);
            // Die Liste der resultierenden Datei-Pfade wird durchlaufen und jede Datei kopiert.
            // Der erste Parameter gibt die Quelle, der Zweite das Ziel an
            // im zweiten Parameter nehme ich dann den neuen, leeren Ordner-Pfad und hänge auf eine sichere Weise
            // Den Datei-Namen an. Dafür gibt es die Methode Path.Combine, die das fehlerfrei erledigt
            foreach (var item in Results)
                File.Copy(item, Path.Combine(ResultPath, Path.GetFileName(item)));

        }

        static string[] DistinctPictures(string[] files)
        {
            // Der Fehler-Text, der in die error.txt geschrieben wird
            string ErrorString = "";
            var PictureHashList = new byte[files.Length][];
            for (int i = 0; i < files.Length; i++)
                // Der try-Block wird in jedem Fall ausgeführt
                try
                {
                    using (Image img = Image.FromFile(files[i]))
                        PictureHashList[i] = new SHA256Managed().ComputeHash(
                            (Byte[])new ImageConverter().ConvertTo(
                            img, typeof(Byte[])));
                }
                // Der catch-Block wird immer dann ausgeführt, wenn im try-Block ein Laufzeitfehler auf tritt
                catch (Exception ex)
                {
                    // Exception ist die Basis-Klasse für alle Fehler-Klassen.
                    // Dort kann man verschiedene Typen verwenden und so z.B.
                    // für die Ableitung "FileNotFoundException" eine gesonderte Fehlerbehandlung einbauen,
                    // Wenn eine Datei nicht gefunden wurde
                    // Ich hab hier einfach nur Exception genommen, um den Absturz des Programmes in jedem Fall zu verhindern.
                    ErrorString += "Error:";
                    ErrorString += "  \r\nDatei:  " + files[i];
                    ErrorString += "  \r\nFehler: " + ex.Message;
                    ErrorString += "\r\n" + new string('-', 20);
                }
            // Hier schreibe ich die error.txt
            // Ein FileStream ist Stream, der geschlossen werden muss, daher verwende ich hier using
            // Der Parameter "FileMode.Create" gibt an, dass die Datei entweder erstellt oder überschrieben wird
            if (ErrorString != "")
                using (FileStream file = new FileStream("error.txt", FileMode.Create))
                // Da der FileStream nur Bytes schreiben kann, brauche ich einen StreamWriter,
                // der für mich in den FileStream schreibt. Auch der muss danach wieder geschlossen werden,
                // daher auch hier wieder using
                    using (StreamWriter writer = new StreamWriter(file))
                        writer.Write(ErrorString);



            var dictionary = new Dictionary<byte[], string>();
            for (int i = 0; i < PictureHashList.Length; i++)
                if (PictureHashList[i] != null)
                    if (!new Func<bool>(() =>
                    {
                        foreach (var item in dictionary.Keys.ToList())
                            if (PictureHashList[i].SequenceEqual(item))
                                return true;
                        return false;
                    }).Invoke())
                        dictionary.Add(PictureHashList[i], files[i]);
            return dictionary.Values.ToArray();
        }
    }
}