Memory-Struktur für Speichergrössen

    • VB.NET

    Es gibt 9 Antworten in diesem Thema. Der letzte Beitrag () ist von Higlav.

      Memory-Struktur für Speichergrössen

      Hallo liebe Community,

      Beim Programmieren kommt man viel nicht darum herum, mit Dateien und deren Grössen zu hantieren. Es konnte teilweise sogar mühsam werden, die Dateigrössen richtig darzustellen. Ich setzte mich also hin, um eine Struktur zu schreiben, die einem diese Arbeit abnimmt.
      Hier möchte ich euch meine Lösung präsentieren:

      Memory(Velocity)-Struktur

      Quellcode

      1. Imports System.Text
      2. Imports System.Text.RegularExpressions
      3. Imports System.IO
      4. Imports System.Net
      7. ''' <summary>
      8. ''' Bietet Formatierungsmöglichkeiten für Byte-Grössen.
      9. ''' </summary>
      10. Public Structure Memory
      11. Implements IComparable, ICloneable
      13. #Region "Initializers"
      15. ''' <summary>
      16. ''' Initialisiert die Struktur mit einem Wert, der den angegebenen Details entspricht.
      17. ''' </summary>
      18. ''' <param name="unit">Die Einheit.</param>
      19. ''' <param name="value">Der Wert</param>
      20. ''' <remarks></remarks>
      21. Public Sub New(unit As MemoryUnit, value#)
      22. If unit = MemoryUnit.Bestbinary OrElse unit = MemoryUnit.Bestdecimal Then Throw New ArgumentOutOfRangeException("unit")
      23. VarBytes = CLng(value * unit)
      24. End Sub
      26. ''' <summary>
      27. ''' Initialisiert die Struktur mit einem Byte-Wert.
      28. ''' </summary>
      29. ''' <param name="amount">Der Wert</param>
      30. ''' <remarks></remarks>
      31. Public Sub New(amount&)
      32. VarBytes = amount
      33. End Sub
      35. #End Region
      37. #Region "Variables"
      39. Private VarBytes&
      40. Public Shared ReadOnly Zero As New Memory(0)
      41. Private Shared ReadOnly VarEndings As New List(Of String)({"{0} B{2}", "{0} K{1}B{2}", "{0} M{1}B{2}", "{0} G{1}B{2}", "{0} T{1}B{2}", "{0} P{1}B{2}", "{0} E{1}B{2}"})
      43. #End Region
      45. #Region "Properties"
      47. ''' <summary>
      48. ''' Gibt die gespeicherte Grösse im angegebenen Format aus oder legt sie fest.
      49. ''' </summary>
      50. ''' <param name="unit">Die Einheit.</param>
      51. ''' <value></value>
      52. ''' <returns></returns>
      53. ''' <remarks></remarks>
      54. Default Public Property Value(unit As MemoryUnit) As Double
      55. Get
      56. If unit = MemoryUnit.Bestbinary OrElse unit = MemoryUnit.Bestdecimal Then Return VarBytes
      57. Return VarBytes / unit
      58. End Get
      59. Set(value As Double)
      60. VarBytes = CLng(value * unit)
      61. End Set
      62. End Property
      64. #End Region
      66. #Region "Functions"
      68. ''' <summary>
      69. ''' Bildet die gespeicherte Grösse in einem geeigneten Byte-basierenden Format ab.
      70. ''' </summary>
      71. ''' <returns></returns>
      72. ''' <remarks></remarks>
      73. Public Overrides Function ToString() As String
      74. Return ToString(MemoryUnit.Bestdecimal)
      75. End Function
      77. ''' <summary>
      78. ''' Bildet die gespeicherte Grösse nach bestimmten Parametern ab.
      79. ''' </summary>
      80. ''' <param name="unit">Die Einheit.</param>
      81. ''' <returns></returns>
      82. ''' <remarks></remarks>
      83. Public Overloads Function ToString(unit As MemoryUnit) As String
      84. Dim First = String.Empty
      85. Dim Second = String.Empty
      86. Dim Border = 1000
      87. If unit = MemoryUnit.Bestbinary OrElse unit.ToString.Contains("bib") Then First = "i" : Border = 1024
      88. If unit.ToString.Contains("bit") Then Second = "it"
      89. If Not unit = MemoryUnit.Bestbinary AndAlso Not unit = MemoryUnit.Bestdecimal Then
      90. Dim S = VarEndings.First(Function(x) x.Substring(4, 1) = Regex.Match(unit.ToString, "^[A-Z]").Value)
      91. Return String.Format(S, Value(unit), First, Second)
      92. End If
      93. Dim D# = VarBytes
      94. For i = 0 To [Enum].GetValues(GetType(MemoryUnit)).Length - 1
      95. If D < Border Then
      96. Return String.Format(VarEndings(i), D.ToString("###0.0#"), First, Second)
      97. End If
      98. D /= Border
      99. Next
      100. Return String.Empty
      101. End Function
      103. ''' <summary>
      104. ''' Initialisiert die Struktur mit einer Dateigrösse.
      105. ''' </summary>
      106. ''' <param name="path">Der Pfad, der auf eine Datei zeigt.</param>
      107. ''' <returns></returns>
      108. ''' <remarks></remarks>
      109. Public Shared Function FromFile(path$) As Memory
      110. Return New FileInfo(path).Length
      111. End Function
      113. ''' <summary>
      114. ''' Initialisiert die Struktur mit der Grösse einer Internetressource.
      115. ''' </summary>
      116. ''' <param name="address">Ein Uri-Objekt, das auf eine Internetressource zeigt.</param>
      117. ''' <returns></returns>
      118. ''' <remarks></remarks>
      119. Public Shared Function FromUri(address As Uri) As Memory
      120. Dim Req = HttpWebRequest.CreateHttp(address)
      121. Using Resp = DirectCast(Req.GetResponse, HttpWebResponse)
      122. Return Resp.ContentLength
      123. End Using
      124. End Function
      126. ''' <summary>
      127. ''' Parst den Wert und die Einheit aus einem String.
      128. ''' </summary>
      129. ''' <param name="str">String, der die Daten zur Grösse beinhaltet</param>
      130. ''' <returns></returns>
      131. ''' <remarks></remarks>
      132. Public Shared Function Parse(str$) As Memory
      133. Dim Dic = GetDic()
      134. Dim Pattern = "(^|[^0-9])(?<Value>[0-9]+?((,|\.)[0-9]+?|))[^0-9,\.]*?(?<Unit>(" & String.Join("|", Dic.ToList.ConvertAll(Function(x) x.Key)) & "))"
      135. If Regex.IsMatch(str, Pattern) Then
      136. Dim M = Regex.Match(str, Pattern, RegexOptions.IgnoreCase)
      137. Dim Value = Double.Parse(M.Groups("Value").Value.Replace(","c, "."c))
      138. Dim Unit = Dic(M.Groups("Unit").Value)
      139. Return New Memory(Unit, Value)
      140. Else
      141. Return Nothing
      142. End If
      143. End Function
      145. Private Shared Function GetDic() As Dictionary(Of String, MemoryUnit)
      146. Dim Dic As New Dictionary(Of String, MemoryUnit)
      147. Dic.Add("(b|byte)", MemoryUnit.Byte)
      148. Dic.Add("(kibit|kibibit)", MemoryUnit.Kibibit)
      149. Dic.Add("(kib|kibibyte)", MemoryUnit.Kibibyte)
      150. Dic.Add("(kbit|kilobit)", MemoryUnit.Kilobit)
      151. Dic.Add("(kb|kbyte|kilobyte)", MemoryUnit.Kilobyte)
      152. Dic.Add("(mebit|mebibit)", MemoryUnit.Mebibit)
      153. Dic.Add("(meb|mebibyte)", MemoryUnit.Mebibyte)
      154. Dic.Add("(mbit|megabit)", MemoryUnit.Megabit)
      155. Dic.Add("(mb|megabyte)", MemoryUnit.Megabyte)
      156. Dic.Add("(gibit|gibibit)", MemoryUnit.Gibibit)
      157. Dic.Add("(gib|gibibyte)", MemoryUnit.Gibibyte)
      158. Dic.Add("(gbit|gigabit)", MemoryUnit.Gigabit)
      159. Dic.Add("(gb|gigabyte)", MemoryUnit.Gigabyte)
      160. Dic.Add("(tebbit|tebibit)", MemoryUnit.Tebibit)
      161. Dic.Add("(tebb|tebibyte)", MemoryUnit.Tebibyte)
      162. Dic.Add("(tbit|terabit)", MemoryUnit.Terabit)
      163. Dic.Add("(tb|terabyte)", MemoryUnit.Terabyte)
      164. Dic.Add("(pbibit|pebibit)", MemoryUnit.Pebibit)
      165. Dic.Add("(pbib|pebibyte)", MemoryUnit.Pebibyte)
      166. Dic.Add("(pbit|petabit)", MemoryUnit.Petabit)
      167. Dic.Add("(pb|petabyte)", MemoryUnit.Petabyte)
      168. Dic.Add("(exbibit)", MemoryUnit.Exbibit)
      169. Dic.Add("(exbib|exbibyte)", MemoryUnit.Exbibyte)
      170. Dic.Add("(ebit|exabit)", MemoryUnit.Exabit)
      171. Dic.Add("(eb|exab|exabyte)", MemoryUnit.Exabyte)
      172. Return Dic
      173. End Function
      175. ''' <summary>
      176. ''' Generiert einen leeren Buffer.
      177. ''' </summary>
      178. ''' <returns></returns>
      179. ''' <remarks></remarks>
      180. Public Function CreateBuffer() As Byte()
      181. Dim Buf(CInt(VarBytes)) As Byte
      182. Return Buf
      183. End Function
      185. ''' <summary>
      186. ''' Klont die aktuelle Instanz.
      187. ''' </summary>
      188. ''' <returns></returns>
      189. ''' <remarks></remarks>
      190. Public Function Clone() As Object Implements ICloneable.Clone
      191. Return New Memory(VarBytes)
      192. End Function
      194. ''' <summary>
      195. ''' Vergleicht zwei Memory-Instanzen und gibt so die Sortierreihenfolge an.
      196. ''' </summary>
      197. ''' <param name="obj">Ein zu vergleichendes Memory-Objekt</param>
      198. ''' <returns></returns>
      199. ''' <remarks></remarks>
      200. Public Function CompareTo(obj As Object) As Integer Implements IComparable.CompareTo
      201. Dim M = DirectCast(obj, Memory)
      202. If Value(MemoryUnit.Byte) < M.Value(MemoryUnit.Byte) Then Return 1
      203. If Me = M Then Return 0
      204. Return - 1
      205. End Function
      207. #End Region
      209. #Region "Operators"
      211. Public Shared Operator +(m1 As Memory, m2 As Memory) As Memory
      212. Return New Memory(m1.VarBytes + m2.VarBytes)
      213. End Operator
      214. Public Shared Operator -(m1 As Memory, m2 As Memory) As Memory
      215. Return New Memory(m1.VarBytes - m2.VarBytes)
      216. End Operator
      217. Public Shared Operator =(m1 As Memory, m2 As Memory) As Boolean
      218. Return m1.VarBytes = m2.VarBytes
      219. End Operator
      220. Public Shared Operator <>(m1 As Memory, m2 As Memory) As Boolean
      221. Return m1.VarBytes <> m2.VarBytes
      222. End Operator
      223. Public Shared Operator <(m1 As Memory, m2 As Memory) As Boolean
      224. Return m1.VarBytes < m2.VarBytes
      225. End Operator
      226. Public Shared Operator >(m1 As Memory, m2 As Memory) As Boolean
      227. Return m1.VarBytes > m2.VarBytes
      228. End Operator
      229. Public Shared Operator /(m1 As Memory, m2 As Memory) As Double
      230. Return m1.VarBytes / m2.VarBytes
      231. End Operator
      232. Public Shared Operator \(m1 As Memory, m2 As Memory) As Long
      233. Return m1.VarBytes \ m2.VarBytes
      234. End Operator
      235. Public Shared Operator <=(m1 As Memory, m2 As Memory) As Boolean
      236. Return m1.VarBytes <= m2.VarBytes
      237. End Operator
      238. Public Shared Operator >=(m1 As Memory, m2 As Memory) As Boolean
      239. Return m1.VarBytes >= m2.VarBytes
      240. End Operator
      241. Public Shared Operator Mod(m1 As Memory, m2 As Memory) As Memory
      242. Return New Memory(m1.VarBytes Mod m2.VarBytes)
      243. End Operator
      245. Public Shared Widening Operator CType(m As Memory) As Long
      246. Return m.VarBytes
      247. End Operator
      248. Public Shared Widening Operator CType(d&) As Memory
      249. Return New Memory(d)
      250. End Operator
      252. Public Shared Operator +(m As Memory, d&) As Memory
      253. Return New Memory(m.VarBytes + d)
      254. End Operator
      255. Public Shared Operator -(m As Memory, d&) As Memory
      256. Return New Memory(m.VarBytes - d)
      257. End Operator
      258. Public Shared Operator =(m As Memory, d&) As Boolean
      259. Return m.VarBytes = d
      260. End Operator
      261. Public Shared Operator <>(m As Memory, d&) As Boolean
      262. Return Not m = d
      263. End Operator
      264. Public Shared Operator <(m As Memory, d&) As Boolean
      265. Return m.VarBytes < d
      266. End Operator
      267. Public Shared Operator >(m As Memory, d&) As Boolean
      268. Return m.VarBytes > d
      269. End Operator
      270. Public Shared Operator /(m As Memory, d#) As Memory
      271. Return New Memory(CLng(m.VarBytes / d))
      272. End Operator
      273. Public Shared Operator \(m As Memory, d&) As Memory
      274. Return New Memory(CLng(m.VarBytes \ d))
      275. End Operator
      276. Public Shared Operator *(m As Memory, d#) As Memory
      277. Return New Memory(CLng(m.VarBytes * d))
      278. End Operator
      279. Public Shared Operator <=(m As Memory, d&) As Boolean
      280. Return m.VarBytes <= d
      281. End Operator
      282. Public Shared Operator >=(m As Memory, d&) As Boolean
      283. Return m.VarBytes >= d
      284. End Operator
      285. Public Shared Operator Mod(m As Memory, d#) As Memory
      286. Return New Memory(CLng(m.VarBytes Mod d))
      287. End Operator
      288. Public Shared Operator ^(m As Memory, d#) As Memory
      289. Return New Memory(CLng(m.VarBytes ^ d))
      290. End Operator
      292. Public Shared Operator /(m As Memory, t As TimeSpan) As MemoryVelocity
      293. Return New MemoryVelocity(m, t)
      294. End Operator
      295. Public Shared Operator /(m As Memory, v As MemoryVelocity) As TimeSpan
      296. Return TimeSpan.FromSeconds(m.VarBytes / v.Value(MemoryUnit.Byte, TimeUnit.Second))
      297. End Operator
      299. #End Region
      300. End Structure
      302. ''' <summary>
      303. ''' Gibt eine Auswahl an Einheiten für die Grösse.
      304. ''' </summary>
      305. ''' <remarks>
      306. ''' <see cref="MemoryUnit.Bestbinary">Bestbinary</see> und
      307. ''' <see cref="MemoryUnit.Bestdecimal">Bestdecimal</see> werden nur für die <see cref="Memory.ToString">ToString</see>-Methode verwendet. Wird bei falscher Handhabung als
      308. ''' <see
      309. ''' cref="MemoryUnit.[Byte]">
      310. ''' Byte
      311. ''' </see>
      312. ''' behandelt.
      313. ''' </remarks>
      314. Public Enum MemoryUnit As Long
      315. [Byte] = 1
      316. Kilobyte = 1000
      317. Kilobit = 1000 \ 8
      318. Kibibyte = CLng(2 ^ 10)
      319. Kibibit = CLng(2 ^ 10) \ 8
      320. Megabyte = 1000000
      321. Megabit = 1000000 \ 8
      322. Mebibyte = CLng(2 ^ 20)
      323. Mebibit = CLng(2 ^ 20) \ 8
      324. Gigabyte = 1000000000
      325. Gigabit = 1000000000 \ 8
      326. Gibibyte = CLng(2 ^ 30)
      327. Gibibit = CLng(2 ^ 30) \ 8
      328. Terabyte = 1000000000000
      329. Terabit = 1000000000000 \ 8
      330. Tebibyte = CLng(2 ^ 40)
      331. Tebibit = CLng(2 ^ 40) \ 8
      332. Petabyte = 1000000000000000
      333. Petabit = 1000000000000000 \ 8
      334. Pebibyte = CLng(2 ^ 50)
      335. Pebibit = CLng(2 ^ 50) \ 8
      336. Exabyte = 1000000000000000000
      337. Exabit = 1000000000000000000 \ 8
      338. Exbibyte = CLng(2 ^ 60)
      339. Exbibit = CLng(2 ^ 60) \ 8
      341. ''' <summary>
      342. ''' Sucht bei Anwendung bei der <seealso cref="Memory.ToString">ToString</seealso>-Methode die optisch beste Einheit(1'024er-Schritte).
      343. ''' </summary>
      344. ''' <remarks>Nicht für die Initialisierung zu verwenden.</remarks>
      345. Bestbinary
      347. ''' <summary>
      348. ''' Sucht bei Anwendung bei der <seealso cref="Memory.ToString">ToString</seealso>-Methode die optisch beste Einheit(1'000er-Schritte).
      349. ''' </summary>
      350. ''' <remarks>Nicht für die Initialisierung zu verwenden.</remarks>
      351. Bestdecimal
      352. End Enum
      354. ''' <summary>
      355. ''' Bietet Formatierungsmöglichkeiten für die Geschwindigkeit bei Byte-basierenden Grössen.
      356. ''' </summary>
      357. Public Structure MemoryVelocity
      358. Implements IComparable, ICloneable
      360. #Region "Initializers"
      362. ''' <summary>
      363. ''' Initialisiert die Struktur mit der Anzahl Bytes und eines Zeitspanne.
      364. ''' </summary>
      365. ''' <param name="memory">
      366. ''' Das <seealso cref="Memory">Memory</seealso>-Objekt, das in einer gewissen Zeit abgearbeitet wurde.
      367. ''' </param>
      368. ''' <param name="time">
      369. ''' Die Zeit, in der das <seealso cref="Memory">Memory</seealso>-Objekt abgearbeitet wurde.
      370. ''' </param>
      371. Public Sub New(memory As Memory, time As TimeSpan)
      372. VarMemory = memory
      373. VarTime = time
      374. End Sub
      376. ''' <summary>
      377. ''' Initialisiert die Struktur mit der Anzahl Bytes und eines Zeitspanne.
      378. ''' </summary>
      379. ''' <param name="memUnit">Die Memory-Einheit</param>
      380. ''' <param name="timeUnit">Die Zeiteinheit </param>
      381. ''' <param name="value">Wert der Geschwindigkeit</param>
      382. Public Sub New(memUnit As MemoryUnit, timeUnit As TimeUnit, value#)
      383. Me.New(0, TimeSpan.FromSeconds(1))
      384. Me.Value(memUnit, timeUnit) = value
      385. End Sub
      387. #End Region
      389. #Region "Variables"
      391. Private VarMemory As Memory
      392. Private VarTime As TimeSpan
      394. #End Region
      396. #Region "Properties"
      398. ''' <summary>
      399. ''' Gibt die gespeicherte Geschwindigkeit im angegebenen Format zurück oder legt sie fest.
      400. ''' </summary>
      401. ''' <param name="memUnit">Das Memory-Format</param>
      402. ''' <param name="timeUnit">Das Zeit-Format</param>
      403. Default Public Property Value(memUnit As MemoryUnit, timeUnit As TimeUnit) As Double
      404. Get
      405. Select Case timeUnit
      406. Case Is = timeUnit.Second
      407. Return VarMemory(memUnit) / VarTime.TotalSeconds
      408. Case Is = timeUnit.Minute
      409. Return VarMemory(memUnit) / VarTime.TotalMinutes
      410. Case Else
      411. Return VarMemory(memUnit) / VarTime.TotalHours
      412. End Select
      413. End Get
      414. Set(value As Double)
      415. Select Case timeUnit
      416. Case Is = timeUnit.Second
      417. VarMemory = New Memory(memUnit, value * VarTime.TotalSeconds)
      418. Case Is = timeUnit.Minute
      419. VarMemory = New Memory(memUnit, value * VarTime.TotalMinutes)
      420. Case Else
      421. VarMemory = New Memory(memUnit, value * VarTime.TotalHours)
      422. End Select
      423. End Set
      424. End Property
      426. #End Region
      428. #Region "Functions"
      430. ''' <summary>
      431. ''' Bildet die gespeicherte Geschwindigkeit in einem geeigneten Format ab(B/s).
      432. ''' </summary>
      433. Public Overrides Function ToString() As String
      434. Return ToString(MemoryUnit.Bestdecimal, TimeUnit.Second)
      435. End Function
      437. ''' <summary>
      438. ''' Bildet die gespeicherte Geschwindigkeit nach bestimmten Parametern ab(X/s).
      439. ''' </summary>
      440. ''' <param name="unit">Das Memory-Format</param>
      441. Public Overloads Function ToString(unit As MemoryUnit) As String
      442. Return ToString(unit, TimeUnit.Second)
      443. End Function
      445. ''' <summary>
      446. ''' Bildet die gespeicherte Geschwindigkeit nach bestimmten Parametern ab(B/x).
      447. ''' </summary>
      448. ''' <param name="unit">Das Zeit-Format</param>
      449. Public Overloads Function ToString(unit As TimeUnit) As String
      450. Return ToString(MemoryUnit.Bestdecimal, unit)
      451. End Function
      453. ''' <summary>
      454. ''' Bildet die gespeicherte Geschwindigkeit nach bestimmten Parametern ab(X/y).
      455. ''' </summary>
      456. ''' <param name="memUnit">Das Memory-Format</param>
      457. ''' <param name="timeUnit">Das Zeit-Format</param>
      458. Public Overloads Function ToString(memUnit As MemoryUnit, timeUnit As TimeUnit) As String
      459. Select Case timeUnit
      460. Case Is = timeUnit.Second
      461. Return CalculateProcessedMemory(TimeSpan.FromSeconds(1)).ToString(memUnit) & "/s"
      462. Case Is = timeUnit.Minute
      463. Return CalculateProcessedMemory(TimeSpan.FromMinutes(1)).ToString(memUnit) & "/m"
      464. Case Else
      465. Return CalculateProcessedMemory(TimeSpan.FromHours(1)).ToString(memUnit) & "/h"
      466. End Select
      467. End Function
      469. ''' <summary>
      470. ''' Initialisiert die Struktur mit einer festgelegten Geschwindigkeit.
      471. ''' </summary>
      472. ''' <param name="memUnit">Das Memory-Format</param>
      473. ''' <param name="timeUnit">Das Zeit-Format</param>
      474. ''' <param name="value">Der Wert der Geschwindigkeit</param>
      475. Public Shared Function FromValue(memUnit As MemoryUnit, timeUnit As TimeUnit, value#) As MemoryVelocity
      476. Dim MV As New MemoryVelocity(New Memory(memUnit, 10), New TimeSpan(0, 0, 10))
      477. MV.Value(memUnit, timeUnit) = value
      478. Return MV
      479. End Function
      481. ''' <summary>
      482. ''' Parst den Wert und die Einheit aus einem String.
      483. ''' </summary>
      484. ''' <param name="str">String, der die Daten zur Grösse beinhaltet</param>
      485. Public Shared Function Parse(str$) As MemoryVelocity
      486. Dim MemUnitDic = GetMemDic()
      487. Dim TimeDic = GetTimeDic()
      488. Dim Pattern = "(^|[^0-9])(?<Value>[0-9]+?((,|\.)[0-9]+?|))[^0-9,\.]*?(?<Memoryunit>({0}))(\/|\s*?per\s*?|\s*?pro\s*?|\s*?in\s*?)(?<Timeunit>({1}))"
      489. Pattern = String.Format(Pattern, String.Join("|", MemUnitDic.ToList.ConvertAll(Function(x) x.Key)), String.Join("|", TimeDic.ToList.ConvertAll(Function(x) x.Key)))
      490. If Regex.IsMatch(str, Pattern) Then
      491. Dim M = Regex.Match(str, Pattern, RegexOptions.IgnoreCase)
      492. Dim Value = Double.Parse(M.Groups("Value").Value.Replace(","c, "."c))
      493. Dim MemUnitstr = M.Groups("Memoryunit").Value
      494. Dim TimeUnitstr = M.Groups("Timeunit").Value
      495. Dim MemUnit = MemUnitDic.ToList.First(Function(x) Regex.IsMatch(MemUnitstr, "^" & x.Key & "$", RegexOptions.IgnoreCase)).Value
      496. Dim TimeUnit = TimeDic.ToList.First(Function(x) Regex.IsMatch(TimeUnitstr, "^" & x.Key & "$", RegexOptions.IgnoreCase)).Value
      497. Return FromValue(MemUnit, TimeUnit, Value)
      498. Else
      499. Return Nothing
      500. End If
      501. End Function
      503. Private Shared Function GetMemDic() As Dictionary(Of String, MemoryUnit)
      504. Dim Dic As New Dictionary(Of String, MemoryUnit)
      505. Dic.Add("(b|byte)", MemoryUnit.Byte)
      506. Dic.Add("(kibit|kibibit)", MemoryUnit.Kibibit)
      507. Dic.Add("(kib|kibibyte)", MemoryUnit.Kibibyte)
      508. Dic.Add("(kbit|kilobit)", MemoryUnit.Kilobit)
      509. Dic.Add("(kb|kbyte|kilobyte)", MemoryUnit.Kilobyte)
      510. Dic.Add("(mebit|mebibit)", MemoryUnit.Mebibit)
      511. Dic.Add("(meb|mebibyte)", MemoryUnit.Mebibyte)
      512. Dic.Add("(mbit|megabit)", MemoryUnit.Megabit)
      513. Dic.Add("(mb|megabyte)", MemoryUnit.Megabyte)
      514. Dic.Add("(gibit|gibibit)", MemoryUnit.Gibibit)
      515. Dic.Add("(gib|gibibyte)", MemoryUnit.Gibibyte)
      516. Dic.Add("(gbit|gigabit)", MemoryUnit.Gigabit)
      517. Dic.Add("(gb|gigabyte)", MemoryUnit.Gigabyte)
      518. Dic.Add("(tebbit|tebibit)", MemoryUnit.Tebibit)
      519. Dic.Add("(tebb|tebibyte)", MemoryUnit.Tebibyte)
      520. Dic.Add("(tbit|terabit)", MemoryUnit.Terabit)
      521. Dic.Add("(tb|terabyte)", MemoryUnit.Terabyte)
      522. Dic.Add("(pbibit|pebibit)", MemoryUnit.Pebibit)
      523. Dic.Add("(pbib|pebibyte)", MemoryUnit.Pebibyte)
      524. Dic.Add("(pbit|petabit)", MemoryUnit.Petabit)
      525. Dic.Add("(pb|petabyte)", MemoryUnit.Petabyte)
      526. Dic.Add("(exbibit)", MemoryUnit.Exbibit)
      527. Dic.Add("(exbib|exbibyte)", MemoryUnit.Exbibyte)
      528. Dic.Add("(ebit|exabit)", MemoryUnit.Exabit)
      529. Dic.Add("(eb|exab|exabyte)", MemoryUnit.Exabyte)
      530. Return Dic
      531. End Function
      533. Private Shared Function GetTimeDic() As Dictionary(Of String, TimeUnit)
      534. Dim Dic As New Dictionary(Of String, TimeUnit)
      535. Dic.Add("(s|second|sekunde)", TimeUnit.Second)
      536. Dic.Add("(min|minute)", TimeUnit.Minute)
      537. Dic.Add("(h|hour|stunde)", TimeUnit.Hour)
      538. Return Dic
      539. End Function
      541. ''' <summary>
      542. ''' Errechnet den zu erwartenden Speicherverarbeitung in einer bestimmten Zeit.
      543. ''' </summary>
      544. ''' <param name="time">Die Zeit, zu der der voraussichtliche Fortschritt erreicht sein wird.</param>
      545. Public Function CalculateProcessedMemory(time As TimeSpan) As Memory
      546. Return Me * time
      547. End Function
      549. ''' <summary>
      550. ''' Errechnet den zu erwartenden zeitlichen Aufwand, eine bestimmte Menge zu verarbeiten.
      551. ''' </summary>
      552. ''' <param name="memory">Die zu verabeitende Menge</param>
      553. Public Function CalculatePassedTime(memory As Memory) As TimeSpan
      554. Return memory / Me
      555. End Function
      557. ''' <summary>
      558. ''' Klont die aktuelle Instanz.
      559. ''' </summary>
      560. Public Function Clone() As Object Implements ICloneable.Clone
      561. Return New MemoryVelocity(VarMemory, VarTime)
      562. End Function
      564. ''' <summary>
      565. ''' Vergleicht zwei MemoryVelocity-Instanzen und gibt so die Sortierreihenfolge an.
      566. ''' </summary>
      567. ''' <param name="obj">Ein zu vergleichendes MemoryVelocity-Objekt</param>
      568. Public Function CompareTo(obj As Object) As Integer Implements IComparable.CompareTo
      569. Dim V = DirectCast(obj, MemoryVelocity)
      570. If Value(MemoryUnit.Byte, TimeUnit.Second) < V.Value(MemoryUnit.Byte, TimeUnit.Second) Then Return 1
      571. If Me = V Then Return 0
      572. Return - 1
      573. End Function
      575. #End Region
      577. #Region "Operators"
      579. Public Shared Operator +(v1 As MemoryVelocity, v2 As MemoryVelocity) As MemoryVelocity
      580. Return FromValue(MemoryUnit.Byte, TimeUnit.Second, v1.Value(MemoryUnit.Byte, TimeUnit.Second) + v2.Value(MemoryUnit.Byte, TimeUnit.Second))
      581. End Operator
      582. Public Shared Operator -(v1 As MemoryVelocity, v2 As MemoryVelocity) As MemoryVelocity
      583. Return v1 + - v2
      584. End Operator
      585. Public Shared Operator -(v As MemoryVelocity) As MemoryVelocity
      586. Return FromValue(MemoryUnit.Byte, TimeUnit.Second, - v.Value(MemoryUnit.Byte, TimeUnit.Second))
      587. End Operator
      588. Public Shared Operator =(v1 As MemoryVelocity, v2 As MemoryVelocity) As Boolean
      589. Return Math.Abs(v1.Value(MemoryUnit.Byte, TimeUnit.Second) - v2.Value(MemoryUnit.Byte, TimeUnit.Second)) < Double.Epsilon
      590. End Operator
      591. Public Shared Operator <>(v1 As MemoryVelocity, v2 As MemoryVelocity) As Boolean
      592. Return Not v1 = v2
      593. End Operator
      594. Public Shared Operator <(v1 As MemoryVelocity, v2 As MemoryVelocity) As Boolean
      595. Return v1.Value(MemoryUnit.Byte, TimeUnit.Second) < v2.Value(MemoryUnit.Byte, TimeUnit.Second)
      596. End Operator
      597. Public Shared Operator >(v1 As MemoryVelocity, v2 As MemoryVelocity) As Boolean
      598. Return v2 < v1
      599. End Operator
      600. Public Shared Operator <=(v1 As MemoryVelocity, v2 As MemoryVelocity) As Boolean
      601. Return v1.Value(MemoryUnit.Byte, TimeUnit.Second) <= v2.Value(MemoryUnit.Byte, TimeUnit.Second)
      602. End Operator
      603. Public Shared Operator >=(v1 As MemoryVelocity, v2 As MemoryVelocity) As Boolean
      604. Return v2 <= v1
      605. End Operator
      606. Public Shared Operator /(v1 As MemoryVelocity, v2 As MemoryVelocity) As Double
      607. Return v1.Value(MemoryUnit.Byte, TimeUnit.Second) / v2.Value(MemoryUnit.Byte, TimeUnit.Second)
      608. End Operator
      609. Public Shared Operator \(v1 As MemoryVelocity, v2 As MemoryVelocity) As Long
      610. Return CLng(v1.Value(MemoryUnit.Byte, TimeUnit.Second)) \ CLng(v2.Value(MemoryUnit.Byte, TimeUnit.Second))
      611. End Operator
      612. Public Shared Operator Mod(v1 As MemoryVelocity, v2 As MemoryVelocity) As MemoryVelocity
      613. Return FromValue(MemoryUnit.Byte, TimeUnit.Second, v1.Value(MemoryUnit.Byte, TimeUnit.Second) Mod v2.Value(MemoryUnit.Byte, TimeUnit.Second))
      614. End Operator
      616. Public Shared Widening Operator CType(v As MemoryVelocity) As Double
      617. Return v.Value(MemoryUnit.Byte, TimeUnit.Second)
      618. End Operator
      619. Public Shared Widening Operator CType(v As MemoryVelocity) As Long
      620. Return CLng(v.Value(MemoryUnit.Byte, TimeUnit.Second))
      621. End Operator
      622. Public Shared Widening Operator CType(d#) As MemoryVelocity
      623. Return FromValue(MemoryUnit.Byte, TimeUnit.Second, d)
      624. End Operator
      625. Public Shared Widening Operator CType(l&) As MemoryVelocity
      626. Return FromValue(MemoryUnit.Byte, TimeUnit.Second, l)
      627. End Operator
      629. Public Shared Operator +(v As MemoryVelocity, d#) As MemoryVelocity
      630. Return FromValue(MemoryUnit.Byte, TimeUnit.Second, v.Value(MemoryUnit.Byte, TimeUnit.Second) + d)
      631. End Operator
      632. Public Shared Operator -(v As MemoryVelocity, d#) As MemoryVelocity
      633. Return v + - d
      634. End Operator
      635. Public Shared Operator =(v As MemoryVelocity, d#) As Boolean
      636. Return Math.Abs(v.Value(MemoryUnit.Byte, TimeUnit.Second) - d) < Double.Epsilon
      637. End Operator
      638. Public Shared Operator <>(v As MemoryVelocity, d#) As Boolean
      639. Return Not v = d
      640. End Operator
      641. Public Shared Operator <(v As MemoryVelocity, d#) As Boolean
      642. Return v.Value(MemoryUnit.Byte, TimeUnit.Second) < d
      643. End Operator
      644. Public Shared Operator >(v As MemoryVelocity, d#) As Boolean
      645. Return v.Value(MemoryUnit.Byte, TimeUnit.Second) > d
      646. End Operator
      647. Public Shared Operator <=(v As MemoryVelocity, d#) As Boolean
      648. Return v.Value(MemoryUnit.Byte, TimeUnit.Second) <= d
      649. End Operator
      650. Public Shared Operator >=(v As MemoryVelocity, d#) As Boolean
      651. Return v.Value(MemoryUnit.Byte, TimeUnit.Second) >= d
      652. End Operator
      653. Public Shared Operator *(v As MemoryVelocity, d#) As MemoryVelocity
      654. Return FromValue(MemoryUnit.Byte, TimeUnit.Second, v.Value(MemoryUnit.Byte, TimeUnit.Second) * d)
      655. End Operator
      656. Public Shared Operator /(v As MemoryVelocity, d#) As MemoryVelocity
      657. Return FromValue(MemoryUnit.Byte, TimeUnit.Second, v.Value(MemoryUnit.Byte, TimeUnit.Second) / d)
      658. End Operator
      659. Public Shared Operator Mod(v As MemoryVelocity, d#) As MemoryVelocity
      660. Return FromValue(MemoryUnit.Byte, TimeUnit.Second, v.Value(MemoryUnit.Byte, TimeUnit.Second) Mod d)
      661. End Operator
      662. Public Shared Operator ^(v As MemoryVelocity, d#) As MemoryVelocity
      663. Return FromValue(MemoryUnit.Byte, TimeUnit.Second, v.Value(MemoryUnit.Byte, TimeUnit.Second) ^ d)
      664. End Operator
      665. Public Shared Operator *(v As MemoryVelocity, t As TimeSpan) As Memory
      666. Return New Memory(MemoryUnit.Byte, v.Value(MemoryUnit.Byte, TimeUnit.Second) * t.TotalSeconds)
      667. End Operator
      669. #End Region
      670. End Structure
      672. ''' <summary>
      673. ''' Gibt eine Auswahl an Zeit-Formaten.
      674. ''' </summary>
      675. Public Enum TimeUnit
      676. Second
      677. Minute
      678. Hour
      679. End Enum


      Nutzen könnt ihr sie auf verschiedene Art und Weise. Was alles funktioniert:
      Bei der Memory-Struktur:
      • Wert in allen Einheitsgrössen abrufen/ändern.
      • Aus String filtern
      • Aus Datei Grösse auslesen
      • Aus Internetressource Grösse auslesen
      • Leeren Buffer generieren
      • +, -, =, <>, <, >, <=, >=, /, \, Mod-Operatoren mit anderen Memory-Objekten
      • Implizite Konvertierung von/zu Long/Double(für Anzahl Bytes)
      • +, -, =, <>, <, >, <=, >=, /, \, *, Mod, ^-Operatoren mit Long/Double-Werten
      • /-Oparator mit TimeSpan-Objekt, um MemoryVelocity zu erhalten
      • /-Oparator mit MemoryVelocity-Objekt, um TimeSpan zu erhalten
      • Formatiermöglichkeit in allen Einheitsgrössen für die ToString-Methode

      Bei der MemoryVelocity-Struktur:
      • Wert in allen Einheitsgrössen abrufen/ändern.
      • Aus String filtern
      • Aus Wert und Einheiten initialisieren.
      • Voraussichtliche Grösse zu einem bestimmten Zeitpunkt errechnen.
      • Voraussichtlichen Zeitaufwand für eine bestimmte Menge errechnen.
      • +, -, -(negieren), =, <>, <, >, <=, >=, /, \, Mod-Operatoren mit anderen MemoryVelocity-Objekten
      • Implizite Konvertierung von/zu Long/Double(für Anzahl Bytes)
      • +, -, =, <>, <, >, <=, >=, /, *, Mod, ^-Operatoren mit Long/Double-Werten
      • *-Oparator mit TimeSpan-Objekt, um Memory zu erhalten
      • Formatiermöglichkeit in allen Einheitsgrössen für die ToString-Methode
      Klassendiagramm:



      Es reicht einfache Mathematik:

      Quellcode

      1. V = n/t
      2. n = t*V
      3. t = n/V


      Beispiel:

      VB.NET-Quellcode

      1. 'Laden von Bytebasierenden Grössen:
      2. Dim DownloadSize = Memory.FromURI(New Uri("http://3.bp.blogspot.com/-Jk0gUehmM40/TmkwT_ZftFI/AAAAAAAAAB8/YyTcq9guuJQ/s1600/msdn.png"))
      3. Dim AdditionalSize As New Memory(MemoryUnit.Byte, 32.4)
      4. Dim FileSize = Memory.FromFile("." & My.Application.Info.AssemblyName)
      6. 'Kombinieren:
      7. Dim FinalSize = DownloadSize + AdditionalSize + FileSize
      9. 'Ausgeben:
      10. Console.WriteLine(DownloadSize.ToString)
      11. Console.WriteLine("+")
      12. Console.WriteLine(AdditionalSize.ToString)
      13. Console.WriteLine("+")
      14. Console.WriteLine(FileSize.ToString)
      15. Console.WriteLine("=")
      16. Console.WriteLine(FinalSize.ToString(MemoryUnit.Megabyte))
      17. Console.ReadLine()
      19. 'Oder auch das funktioniert:
      20. Dim StringToParse = "Die Datei ist ca. 128,43 Megabyte gross und wird mit einer Geschwindigkeit von 42.32 Mbit/s übertragen."
      21. Dim ExtractedMemory = Memory.Parse(StringToParse)
      22. Dim ExtractedMemoryVelocity = MemoryVelocity.Parse(StringToParse)
      23. Dim TimeOfCompletion = ExtractedMemory / ExtractedMemoryVelocity


      Grüsse

      Higlav

      Dieser Beitrag wurde bereits 19 mal editiert, zuletzt von „Higlav“ ()

      Hab zwar grad keinen Bock, das Zeugs komplett neu zu machen, jedoch kann ich dir ja nen Ansatz geben, wie ich es machen würde:
      Anstatt den dutzenden Funktionen wie FromKiloBytes und Properties wie Gigabytes, würde ich zwei Funktionen machen:

      VB.NET-Quellcode

      1. Public Shared Function Create(unit As MemorySizeUnit, value As Long) As Memory
      3. Public Function GetValue(unit As MemorySizeUnit) As Double
      5. Public Enum MemorySizeUnit As Long
      6. Bit = 1
      7. [Byte] = 8
      8. KiloBit = Bit * 1000
      9. KibiBit = Bit * 1024
      10. KiloByte = [Byte] * 1000
      11. KibiByte = [Byte] * 1024
      12. MegaBit = Bit * CLng(1000 ^ 2)
      13. MebiBit = Bit * CLng(1024 ^ 2)
      14. MegaByte = [Byte] * CLng(1000 ^ 2)
      15. MebiByte = [Byte] * CLng(1024 ^ 2)
      16. '...
      17. End Enum

      Über die Werte im Enum könntest du dann ganz einfach die einzelnen Werte berechnen :).

      So, ich habe gerade ein paar Fehler ausgemerzt. Jetzt müsste soweit alles funktionieren(die ToString-Methode hatte einen kleinen Haken).