Formatieren von Dateigrößen

[Sir Rufo]

Nachdem ich hier http://www.delphipraxis.net/1318130-post5.html diesen Code gefunden habe

Delphi-Quellcode:

function TForm1.GetSizeAsString(Size: Int64): string;
var
  new: Extended;
  Sign: String;
  c: Integer;
begin
  c:=0;
  new:=Size;
  while new>1024 do
  begin
    new:=new/1024;
    Inc(c);
  end;
  case c of
    0: Sign:=' Byte';
    1: Sign:=' KB';
    2: Sign:=' MB';
    3: Sign:=' GB';
    4: Sign:=' TB';
    5: Sign:=' PB';
    6: Sign:=' EB';
    7: Sign:=' ZB';
    8: Sign:=' YB';
  else
    Sign:=' ('+intToStr(c)+')';
  end;
  Result:=FormatFloat('#,##0.00', new)+Sign;
end;

fielen mir auch wieder meine Sünden und guten Vorsätze ein, die ich jedes mal in einem Gedanken begehe (Sünden) und vornehme (Vorsätze), wenn ich so eine Darstellung der Größe benötige. Schnell was gebaut und gut - schön machen wir es wenn wir Zeit haben ...

Hier einmal für alle, die solche Kleinigkeiten auch immer vor sich herschieben, einen süßen Record Helper der sich um die Darstellung kümmert.

• Berücksichtigt habe ich dabei auch die unterschiedliche Zählweisen von den Platten-Herstellern (und apple) mit der Basis 1000 und dem Rest der Welt mit der Basis 1024.
• Der String für die Darstellung wird bis 999,9 YB nie größer als 8 Zeichen breit werden.

Delphi-Quellcode:

type
  TSizeUnit = ( One, Kilo, Mega, Giga, Tera, Peta, Exa, Zetta, Yotta );

  TSizeInBytes = type Int64;

  HSizeInBytes = record helper for TSizeInBytes
  type
    TBase = ( f1000, f1024 );

  const
{$IFDEF MACOS}
    DefaultBase = TBase.f1000; // disc manufacturer/apple default
    AltBase     = TBase.f1024;
{$ELSE}
    DefaultBase = TBase.f1024; // microsoft default
    AltBase     = TBase.f1000;
{$ENDIF}
    BaseFactor: array [ TBase ] of Integer = ( 1000, 1024 );

    ByteSizeFormat: array [ TSizeUnit ] of string = (
      {} ',0 "Byte"',
      {} ',0.0 "KB"',
      {} ',0.0 "MB"',
      {} ',0.0 "GB"',
      {} ',0.0 "TB"',
      {} ',0.0 "PB"',
      {} ',0.0 "EB"',
      {} ',0.0 "ZB"',
      {} ',0.0 "YB"' );

    function ToFloat( const ASizeUnit: TSizeUnit ): Double; overload;
    function ToFloat( const ABase: TBase; const ASizeUnit: TSizeUnit ): Double; overload;

    function ToString( ): string; overload;
    function ToString( const ASizeUnit: TSizeUnit ): string; overload;
    function ToString( const ABase: TBase ): string; overload;
    function ToString( const ABase: TBase; const ASizeUnit: TSizeUnit ): string; overload;
    function ToString( const ABase: TBase; const AFormatSettings: TFormatSettings ): string; overload;
    function ToString( const ABase: TBase; const ASizeUnit: TSizeUnit; const AFormatSettings: TFormatSettings ): string; overload;
  end;

{ HSizeInBytes }

function HSizeInBytes.ToString(
  const ABase          : TBase;
  const AFormatSettings: TFormatSettings ): string;
var
  current: TSizeUnit;
  size   : Double;
begin
  current := low( TSizeUnit );
  size    := Self;
  while ( size >= 1000 ) and ( current < high( TSizeUnit ) ) do
    begin
      size := size / BaseFactor[ ABase ];
      Inc( current );
    end;
  Result := FormatFloat( ByteSizeFormat[ current ], size );
end;

function HSizeInBytes.ToFloat( const ASizeUnit: TSizeUnit ): Double;
begin
  Result := ToFloat( DefaultBase, ASizeUnit )
end;

function HSizeInBytes.ToFloat(
  const ABase    : TBase;
  const ASizeUnit: TSizeUnit ): Double;
var
  current: TSizeUnit;
begin
  Result  := Self;
  current := low( TSizeUnit );
  while current < ASizeUnit do
    begin
      Result := Result / BaseFactor[ ABase ];
      Inc( current );
    end;
end;

function HSizeInBytes.ToString(
  const ABase          : TBase;
  const ASizeUnit      : TSizeUnit;
  const AFormatSettings: TFormatSettings ): string;
begin
  Result := FormatFloat( ByteSizeFormat[ ASizeUnit ], ToFloat( ASizeUnit ), AFormatSettings );
end;

function HSizeInBytes.ToString: string;
begin
  Result := ToString( DefaultBase, FormatSettings );
end;

function HSizeInBytes.ToString( const ASizeUnit: TSizeUnit ): string;
begin
  Result := ToString( DefaultBase, ASizeUnit, FormatSettings );
end;

function HSizeInBytes.ToString( const ABase: TBase ): string;
begin
  Result := ToString( ABase, FormatSettings );
end;

function HSizeInBytes.ToString(
  const ABase    : TBase;
  const ASizeUnit: TSizeUnit ): string;
begin
  Result := ToString( ABase, ASizeUnit, FormatSettings );
end;

[Dejan Vu]

Solltest Du nicht (optional) zwischen MB und MiB usw. unterscheiden, je nachdem, ob Du als Basis die 1000 oder 1024 nimmst? Und Ja. Es ("Das Mebi und der Gibi") erzeugt Würgereflexe.

[Sir Rufo]

Es ist ja nur Zucker für die Darstellung. Wichtig war mir nur die korrekte Daratellung auf der jeweiligen Plattform um den Benutzer nicht zu überfordern/verwirren.

Mit den Darstellungswerten wird nicht weitergerechnet und sind auch nicht entscheidungsrelevant - bzw. wenn, dann spielt der Unterschied auch keine Geige.

Eine echte Wahrheit gibt es auch nicht, nur eine Erwartungshaltung. Apple hat sich dazu entschieden so zu rechnen wie die Plattenhersteller (Basis 1000) und der Rest bleibt bei Basis 1024.

Was ist jetzt wirklich richtig? Ich weiß es auch nicht ... darum einfach so, wie es auf der Plattform erwartet wird.

[Captnemo]

http://www.mathemedien.de/kilobyte.html

[Perlsau]

Zitat von Sir Rufo:

Eine echte Wahrheit gibt es auch nicht, nur eine Erwartungshaltung.

So ist es

Zitat von Sir Rufo:

Apple hat sich dazu entschieden so zu rechnen wie die Plattenhersteller (Basis 1000) und der Rest bleibt bei Basis 1024.
Was ist jetzt wirklich richtig? Ich weiß es auch nicht ... darum einfach so, wie es auf der Plattform erwartet wird.

Naja, die meisten Kunden, mit denen ich bislang zu tun hatte, wissen so gut wie nichts über Bits und Bytes oder andere Zahlensysteme als jenes, das sie gewöhnlich verwenden. Das wird wohl sprachübergreifend – also auch z.B. in England und Frankreich – so sein. Ich gebe daher Datei-Größen grundsätzlich immer in Byte an, schön getrennt durch das jeweilige Tausender-Trennzeichen. Den meisten fällt nicht einmal auf, wenn solche Angaben nicht im Dezimalsystem vorliegen ... die gehen schlichtweg davon aus, Kilo = Tausend und Mega = Million und Giga = KiloMillion. Bei allem anderen stellt die gewöhnliche Vorstellungskraft ihren Dienst ein und hinterläßt einen verwirrten Anwender.

[Sir Rufo]

Wichtig ist mir hier eine Gleichheit bei den Größenangaben.

Wenn der Explorer sagt, die Datei ist 120,4MB groß, dann soll meine Anwendung auch diesen Wert wiedergeben. Und wenn der Finder 120,4MB ausgibt, dann soll das meine Anwendung auch.

Und ja, die wenigsten wissen, wie die Umrechnungsbasis ist.

Was aber alle wissen ist, dass 120,4MB nicht gleich 114,8MB ist und 120,4MB nicht gleich 126,2MB ist.
Ist es aber eben doch 120,4MB=114,8MiB und 120,4MiB=126,2MB.

Die meisten achten aber nur auf den Zahlenwert und bemerken nicht das kleine entscheidende i. Dann kann ich es auch gleich weglassen und die Einheit so ausgeben, wie es auf der Plattform gemacht wird und dort finde ich auch kein kleines i.

Man muss also abwägen und sich zwischen absolut korrekt und verständlich entscheiden.

Ich wurde bislang auch - von Kunden - nie darauf angesprochen worden, dass da eigentlich ein i mit hineingehört, wohl aber warum denn die 1TB Festplatte gar nicht 1TB hat

[Captnemo]

Naja, den größten Teil der Kunden/Anwender wird das wohl auch nicht interessieren.
Ärgerlich ist's nur dann wenn eine Datenmenge mal wieder nicht auf einen Datenspeicher passt, weil der eine so und der andere so rechnet.

[r.koch]

"Man muss also abwägen und sich zwischen absolut korrekt und verständlich entscheiden."

Was juckt mich eigentlich noch Pascal, wenn ich Seattle habe?

Seit Pascal geht mir Assembler sowas vom am Arsch vorbei, wie das Achteck damals am Rad...

Man entwickelt sich halt weiter und vertraut dem Fortschritt (dringend benötigtes Klopapier per amazon prime).