böse funktionen

Es gibt 7 Antworten in diesem Thema. Der letzte Beitrag () ist von ~blaze~.

    böse funktionen

    folgendes entstund aus einer Privaten Konversation mit SeriTools. Ich hatte gefragt, ob er die Auflistung Böse Funktionen nicht auch nach Themen gruppiert darstellen möge, und das hier ist quasi ein Exposee.
    Habich in Off-Topic gemacht, weil per PM kann man nur 5000 Zeichen, und keine DateiAnhänge.

    Die "bösen" Funktionen, bisserl geordnet nach Bereichen:
    • keine böse Funktion
      (Also eh ich zB. eine Methode selber schreibe, nehme ich schon auch Zeugs aussm VisualBasic-Namespace.)
      1. AscW() - .NET: bei konstantem Parameter: AscW(), ansonsten: System.Convert.ToInt16()
      2. AppActivate() - .NET: Leider keine einfache Alternative, da AppActivate() wohl direkt auf die WINAPI zugreift.
      3. InputBox() - .NET: Eigenen Dialog verwenden, viel mehr Möglichkeiten
      4. StrReverse() - .NET: selber schreiben (wenn man denn sowas eigenartiges je brauchen täte).
      5. MsgBox() - .NET: System.Windows.Forms.MessageBox.Show() IMO: ob nu Messagebox oder MsgBox: ist doch eh ziemlich mies vonne Experience her. Also setzt man ein, wos selten gebraucht wird, und der Aufwand eines ordentlichen Dialoges auf später vertagt wern kann.
      6. CreateObject("Com.Object.Name") - .NET: System.Activator.CreateInstance(System.Type.GetTypeFromProgID("Com.Object.Name"))
      7. GetObject() - .NET: z.B.: codeproject.com/KB/cs/CSGetObject.aspx

    • Auflistungen
      1. IsArray(), IsDate(), IsDBNull() etc. - .NET: Typvergleich ausführen
      2. LBound() - .NET: Array.GetLowerBound()
      3. UBound() - .NET: Array.GetUpperBound()
      4. ReDim - .NET: Verwendung von AuflistungsKlassen, wie List(Of T)
      5. ArrayList - .NET: List(Of T)
      6. Collection (VB6) - .NET: List(Of T) oder Dictionary(Of TKey, TValue)

    • Reflection
      1. CallByName() - .NET: Late Binding ist schlecht! Es würde über System.Refelection gehen.
      2. SystemTypeName() - .NET: unnötig
      3. TypeName() - .NET: .GetType.Name/FullName()
      4. VarType(), VbTypeName() - .NET: unnötig.

    • File-Handling
      1. ChDir() bzw. ChDrive() - .NET: System.IO.Directory.SetCurrentDirectory() bzw. Eigenschaft System.Environment.CurrentDirectory() setzen
      2. CurDir() - .NET: System.IO.Directory.GetCurrentDirectory() bzw. Eigenschaft System.Environment.CurrentDirectory() auslesen
      3. Dir() - .NET: System.IO.GetDirectoryInfo() und die dazugehörigen Klassen verwenden.
      4. File*(), EOF(), FreeFile(), Input(), Loc(), Lock() etc., also Dateizugriff in VB6 - .NET: System.IO-Namespace benutzen
      5. Kill() - .NET: System.IO.File.Delete()
      6. MkDir() - .NET: System.IO.Directory.CreateDirectory()
      7. Rename() - .NET: System.IO.File/Directory.Move()
      8. RmDir() - .NET: System.IO.Directory.Delete()
      9. & und annere String-Operationen mit Dateipfaden - .NET: System.IO.Path.Combine und annere Path-Methoden nutzen

    • Fehlerbehandlung
      1. On Error GoTo ... - .NET: TryCatch - Konzept verwenden
      2. ErrorToString() - .NET: TryCatch - Konzept verwenden
      3. GetException() - .NET: TryCatch - Konzept verwenden

    • Strings
      1. Asc() - .NET: AscW()
      2. Chr() - .NET: ChrW
      3. CBool(), CByte(), CChar(), CDate(), CDbl(), CDec(), CInt(), CLng(), CObj(), CSByte(), CShort(), CSng(), CStr(), CUInt(), CULng(), CUShort() - diese Schlüsselworte sind i.a. sehr performant - bei Konstanten werden sie zT. schon vom Compiler ausgewertet und nehmen zur Laufzeit keine Rechenzeit in Anspruch.
        sie sind aber nicht dazu konzipiert, um von String zu konvertieren - dafür sind die Parse-Functions des ZielTypen vorgesehen (DateTime.Parse(), Boolean.Parse(), ...).
      4. Format(), Format* - .NET: System.String.Format()
      5. GetChar() - .NET: deinString(index) bzw. deinString.Char(index)
      6. InStr() - .NET: String.Contains() bzw. String.IndexOf()
      7. InStrRev() - .NET: String.LastIndexOf()
      8. Join() - .NET: String.Join() oder string &= "...", bei vielen Verkettungen ist ein StringBuilder empfehlenswert.
      9. LCase() - .NET: String.ToLower()
      10. Left(), Right(), Mid() - .NET: String.Substring()
      11. Len() - .NET: String.Length()
      12. LTrim() - .NET: String.TrimStart(Nothing)
      13. LSet(), RSet(), Space() - .NET: String.PadLeft()/PadRight()
      14. Oct(), Hex() - .NET: Convert.ToString(value,8) (oktal), Convert.ToString(value,16) (hexadezimal), s.a. Convert.ToString(value,2) (binär)
      15. Replace() - .NET: String.Replace()
      16. Split() - .NET: String.Split()
      17. Str() - .NET: .ToString()
      18. StrComp() - .NET: String.Compare() / String.CompareTo()
      19. StrConv(conv) - .NET: im nicht-asiatischen Sprachraum unnötig - einzig mit VbStrConv.ProperCase als Parameter manchmal sinnvoll
      20. StrDup() - .NET: String.Pad-Left/-Right, oder zB: New String(" "c, 20) erzeugt einen String mit 20 Spaces.
      21. UCase() - .NET: String.ToUpper()
      22. Val() - .NET: explizite Typkonvertierung durchführen (z.B. .ToString())

    • Sonstige: die Aufzählung versucht nach Wichtigkeit geordnet zu sein
      1. Date...(), Day(), Hour() etc. - .NET: Die Klassen System.DateTime und System.TimeSpan bieten alle Funktionalität, die man sich zur Behandlung von Zeit-Werten nur wünschen kann - Zeiten-Handling ist im Grunde ein ähnlich komplexer Bereich wie das String-Handling
      2. Or / And - .NET: OrElse / AndAlso
      3. IIf() - .NET: If(expression, TruePart, FalsePart) oder If(expression, FalsePart)
      4. Shell() - .NET: System.Diagnostics.Process.Start()
      5. Command() - .NET: System.Environment.CommandLine()
      6. Environ() - .NET: System.Environment.GetEnvironmentVariable()
      7. *Setting(), GetAllSettings() - .NET: Microsoft.Win32.Registry/RegistryKey benutzen
      8. Randomize(), Rnd() - .NET: System.Random benutzen.
      9. Choose(index, variable) - .NET: variable(index) oder (bei manchen Listen o.ä.) variable.Item(index)
      10. Beep() - .NET: Keine äquivaltente Methode (benutzt WINAPI), außer für Konsolenfenster: System.Console.Beep() - Achtung: Funktioniert nicht auf XP x64/Vista x64, wurde in Windows 7 gelöst.
      11. DDB() - .NET: Folgende Formel anstatt Parameter benutzen: Depreciation / Period = ((Cost – Salvage) * Factor) / Life
      12. Filter() - .NET: Keine direkte Entsprechung
      13. Fix(), Int() - .NET: System.Math.Truncate()
      14. FV() - .NET: selber berechnen.
      15. Hex() - .NET: Convert.ToString(value,16)
      16. IPmt() - .NET: selber berechnen.
      17. IRR() - .NET: selber berechnen.
      18. IsNothing() - .NET: If variable Is Nothing Then [...]
      19. MIRR() - .NET: selber berechnen.
      20. NPer() - .NET: selber berechnen.
      21. NPV() - .NET: selber berechnen.
      22. Pmt(), PPmt(), PV() - .NET: selber berechnen.
      23. QBColor() - .NET: unnötig.
      24. Rate() - .NET: selber berechnen.
      25. RGB() - .NET: Color-Klasse benutzen.
      26. SLN() - .NET: selber berechnen.
      27. Switch() - .NET: Switch benutzen bzw. While oder For
      28. SYD() - .NET: selber berechnen.
    Dateien

    • BoeseCalls.txt

      (6,94 kB, 194 mal heruntergeladen, zuletzt: )

    Dieser Beitrag wurde bereits 11 mal editiert, zuletzt von „ErfinderDesRades“ ()

    Hi
    So eine Auflistung hatten wir schon mal hier im Forum.

    Aber ich habe gleich noch mal eine Frage. AscW und ChrW haben einen größeren Raum zur Verfügung, als Chr und Asc. Die Char-Struktur selbst ist 1 Byte lang (wenn man System.Runtime.InteropServices.Marshal.SizeOf(GetType(Char)) aufruft). Dadurch lässt sich darauf schließen, dass die Differenzierung, die bei Sprachen wie C oder C++ auch in VB da ist, aber nicht offensichtlich ist. Wahrscheinlich ist das einfach eine Struktur, die ein Byte hat, das praktisch auf das erste Byte des Charakters zeigt... Bei Strings ist das ja ähnlich, die enthalten eigentlich nur ein Char-Feld, das wohl auf den ersten Buchstaben zeigt und die restlichen Buchstaben sind halt danach im Memory, ähnlich, wie beim Array. Hast du eine Quelle, wo du die Information her hast?

    Ich hab jetzt nicht alle durchgeschaut, aber mir ist noch aufgefallen, dass IIf schon einen kleinen Unterschied zu If hat. Sorry, wenn das jetzt wie klugscheißen rüber kommt, aber bei IIf werden die beiden Parameter ausgewertet, bei If nicht, da das ja fester Bestandteil der Sprache ist und keine Funktion. Eventuell sollte man das über Variablen lösen.

    Edit: Das gabs hier: [VB 2010] "Böse" VB6/VB 2003-Funktionen - und ihre "guten"/besseren neuen VB.NET-Alternativen

    Edit 2: Schreib doch bitte zukünftig immer die Quelle hinzu, wenn du etwas kopierst (und veränderst)

    Gruß
    ~blaze~

    Das entstund aus einer Privaten Konversation mit SeriTools. Ich hatte gefragt, ob er die Auflistung nicht auch nach Themen gruppiert darstellen möge, und das hier ist quasi ein Exposee.
    Habich in Off-Topic gemacht, weil per PM kann man nur 5000 Zeichen, und keine DateiAnhänge.

    Char ist 2 Byte groß, daher mussich zugeben, dassich den Sinn von Chr und Asc ühaupt nicht verstehe.

    Ja, IIF wertet beide zweige aus, genauso wie And und Or.
    Letztere müssten auch in die Liste, denn es ist nur extrem selten erwünscht, dass beide Zweige ausgewertet werden.
    So selten, dass man es, wenn man es wünscht, IMO mittels extra Variablen explizit coden sollte.

    Mir ist eher unwohl mit GetObject, CreateObject:
    Kann man wirklich mit Activator.CreateInstance das gute alte CreateObject("Excel.Application") ersetzen?
    Und eh ich mich da auf diesen c#-workaround einlassen täte, würdich doch beim GetObject bleiben.

    Aber hier noch eine Alternative, die noch mehr leistet als GetObject: [VB 2005] auf laufende Excel-Instanz zugreifen

    So, jetzt packich aber GetObject, CreateObject in die nicht-bösen.
    Weil ich find, böse ist nur, wozus eine bessere Alternative gibt - wenn was vermurkst ist, aber alternativlos, gehörts trotzdem zu den guten ;)

    Dieser Beitrag wurde bereits 1 mal editiert, zuletzt von „ErfinderDesRades“ ()

    Hallo ErfinderDesRades,

    vielen Dank für die Aufstellung.
    Auch ich finde mich da in teilen des Bösen wieder.

    Persönlich konvertiere ich gerne mit CInt und CDate - versuch das nun aber umzustellen.

    Vielleicht könntest du das noch um z.b. Pfadangaben erweitern.

    Path.Combine anstatt "C:\" + "meinPfad"

    Auf so nette Dinge wie PathSeperatorChar oder die konstanten für die Tausendertrennung und Kommasetzung sollte auch eingegangen werden.
    Denn da gibt es auch viele "böse" Vorgehensweisen.

    Gruss

    mikeb69

    Wie ich oben geschrieben habe, ist der Wertetyp Char 1 Byte groß. Das kannst du auch mit System.Runtime.InteropServices.Marshal.SizeOf(GetType(Char)) nachprüfen. Was der Compiler dann damit macht, ist wieder eine andere Geschichte. Übrigens haben Chars scheinbar einen Wertebereich von -32768 bis 65535. Das sind also mehr als 16 Bit, wenn alle Zahlen besetzt sind. Ich weiß ja, dass Chars größer als 8 Bit sind, aber es gibt eben schon einen Unterschied zwischen ChrW, Chr, AscW und Asc.

    Edit: Mal grad noch mal auf der MSDN nachgeforscht - der Zahlenbereich ist tatsächlich, wie bei Int16. Wahrscheinlich werden die Zahlen größer 32767 ebenfalls als negative angesehen. Die Umwandlungsfunktionen sind abhängig von der Code-Page des aktuellen Threads, was sowieso klar ist, also genügen Asc und Chr bei einem Zeichensatz, er nur 1 Byte benötigt.

    Gruß
    ~blaze~

    Dieser Beitrag wurde bereits 1 mal editiert, zuletzt von „~blaze~“ ()

    Ja, habe jetzt auch einen MSDN-Artikel zu Asc/AscW gefunden.
    Nur verstehe ich nix. Also es soll wohl ieinen Unterschied geben in anneren Zeichensätzen als UniCode. Der Witz ist nur, dass in .Net alle Strings Unicode sind. Und in Unicode belegt ein CodePunkt 2 Bytes.

    Auch dass SizeOf(Char) 1 ist, findich irre. Denn Char.MaxValue ist mit ChrW(65535) definiert, und 65535 sind 2 Byte.

    Wie findste diesen?

    VB.NET-Quellcode

    1. o = Buffer.ByteLength("f".ToCharArray)

    o=2!

    böse funktionen

    Msdn schrieb:


    ' Array name Array type Length ByteLength
    ' ---------- ---------- ------ ----------
    ' bytes System.Byte[] 10 10
    ' bools System.Boolean[] 5 5
    ' chars System.Char[] 5 10

    Interessant was bei einem Char Array rauskommt ;)

    AppActivate() - .NET: Leider keine einfache Alternative, da AppActivate() wohl direkt auf die WINAPI zugreift.

    Funktioniert nicht Focus beim Formular - Ansonsten halt SetForeground WinAPI^^
    ChrW,AscW dürfte doch mit Convert.ToChar/Convert.ToByte/ToInt16 funktionieren...
    Ich wollte auch mal ne total überflüssige Signatur:
    ---Leer---

    Wie gesagt, der Compiler kann das auch anders übersetzen. In C++ ist char auch 1 Byte lang. Wenn du einen Char anlegst, kannst du auch 2 Bytes nehmen und den Char auf das 1. Byte zeigen lassen. Wenn du dann den Char auswertest, ist der Wert im Char selber das 1. Byte. Wenn du aber den Char als Short liest, wird auch das 2. Byte ausgelesen. Der Compiler könnte so intelligent sein, dass er Chars je nach Fall auswertet (auf Basis der konstanten Ausdrücke, wie Chr, Asc).

    Gruß
    ~blaze~

Facebook
Telefonspende