Dateigrößenangaben in C# menschenlesbar formatieren

Um aus Byte-Angaben (z.B. von Dateigrößen) menschenlesbare Werte (z.B. „12.5GB“) zu machen, sowie den anderen Weg, habe ich mir ein bisschen Code geschrieben bzw. von Stack Overflow zusammen gesucht:

public static class SizeTranslationHelper
{
    /// <summary>
    /// Converts bytes to human-readable, e.g. "12.5GB".
    /// </summary>
    public static string MakeLazy(ulong byteCount)
    {
        string[] suf = { @"B", @"KB", @"MB", @"GB", @"TB", @"PB", @"EB" }; //Longs run out around EB
        if (byteCount == 0)
            return "0" + suf[0];
        var bytes = (ulong)Math.Abs((decimal)byteCount);
        var place = Convert.ToInt32(Math.Floor(Math.Log(bytes, 1024ul)));
        var num = Math.Round(bytes / Math.Pow(1024ul, place), 1);
        return (Math.Sign((decimal)byteCount) * num).ToString(CultureInfo.InvariantCulture) + suf[place];
    }

    /// <summary>
    /// Converts human-readable, e.g. "12.5GB", to bytes.
    /// </summary>
    public static ulong TranslateLazySize(string sizeLazy)
    {
        sizeLazy = sizeLazy.ToLowerInvariant();

        ulong result = 0;
        if (tryParse(ref result, sizeLazy, @"b", 1ul))
        {
            return result;
        }
        else if (tryParse(ref result, sizeLazy, @"kb", 1024ul))
        {
            return result;
        }
        else if (tryParse(ref result, sizeLazy, @"mb", 1024ul * 1024ul))
        {
            return result;
        }
        else if (tryParse(ref result, sizeLazy, @"gb", 1024ul * 1024ul * 1024ul))
        {
            return result;
        }
        else if (tryParse(ref result, sizeLazy, @"tb", 1024ul * 1024ul * 1024ul * 1024ul))
        {
            return result;
        }
        else if (tryParse(ref result, sizeLazy, @"pb", 1024ul * 1024ul * 1024ul * 1024ul * 1024ul))
        {
            return result;
        }
        else if (tryParse(ref result, sizeLazy, @"eb", 1024ul * 1024ul * 1024ul * 1024ul * 1024ul * 1024ul))
        {
            return result;
        }
        else
        {
            decimal r;
            if (decimal.TryParse(sizeLazy, NumberStyles.AllowDecimalPoint, CultureInfo.InvariantCulture, out r))
            {
                return (ulong)r;
            }
            else
            {
                throw new Exception(string.Format(@"Cannot parse '{0}' to number.", sizeLazy));
            }
        }
    }

    private static bool tryParse(ref ulong result, string sizeLazy, string suffix, ulong factor)
    {
        decimal r;
        if (
            sizeLazy.EndsWith(suffix) &&
            decimal.TryParse(sizeLazy.Substring(0, sizeLazy.Length - suffix.Length), NumberStyles.AllowDecimalPoint, CultureInfo.InvariantCulture, out r))
        {
            result = (ulong)(r * factor);
            return true;
        }
        else
        {
            return false;
        }
    }
}

Hier noch der Pastebin-Eintrag dazu.

Kurztipp: HTTP-URLs in Windows Explorer öffnen

Manchmal ist es nützlich, zu wissen, dass Ihr in Windows Explorer (also nicht Internet Explorer) direkt HTTP-URLs eingeben könnt.

Also z.B. im Datei-Öffnen-Dialogfenster.

Anwendungszenario – Internet-Bild lokal bearbeiten

Wollt Ihr z.B. ein tolles Bild aus dem Internet lokal bearbeiten, so ist der übliche Weg:

  1. Webbrowser starten. (Also Google Chrome, was sonst)
  2. URL der Seite öffnen, auf der das Bild enthalten ist.
  3. Rechtsklick auf das Bild.
  4. „Speichern unter“ auswählen.
  5. Lokales Zeichenprogramm starten (Also Paint.NET).
  6. Datei-Öffnen-Dialogfenster anzeigen lassen.
  7. Das vorher heruntergeladene Bild suchen und öffnen.

Mit dem Wissen, dass das auch direkt in Windows Explorer geht (vermutlich über den eingebauten WebDAV-Client), könnt Ihr diese Prozedur abkürzen:

  1. Lokales Zeichenprogramm starten.
  2. Datei-Öffnen-Dialogfenster anzeigen lassen.
  3. URL des Bildes eingeben und direkt öffnen.

Hat mir schon oft geholfen, ggf. ist das auch für Euch mal nützlich. Funktioniert auch prima, wenn Ihr auf einer Seite ein Bild downloaden möchtet um es auf einer anderen Seite upzuloaden.

Geht natürlich mit beliebigen Dateien (z. B. PDF), nicht nur Bildern.

Fehlerhafte Microsoft JET-Installation reparieren

Um eine fehlerhafte Microsoft JET- oder Microsoft MDAC-Installation zu reparieren hat mir heute ein kostenloses Werkzeug geholfen:

CSRepair“ von der Firma Macropool (hier der direkte EXE-Download).

Im konkreten Fall war es der Fehler

Das COM-Objekt mit der CLSID {DE88C160-FF2C-11D1-BB6F-00C04FAE22DA} ist ungültig oder wurde nicht registriert

Nach dem Ausführen des Werkzeugs war der Fehler behoben.

Update 27.04.2017

Die Links oben zu CSRepair sind tot, deshalb habe ich sie entfernt. Eventuell hilft dieses Tool von Microsoft weiter.

Siehe auch meinen Artikel zum Reparieren von JET-Dateien.