Exotische Frage um Klassen realisierung

  • VB.NET

Es gibt 15 Antworten in diesem Thema. Der letzte Beitrag () ist von Dodo.

    Exotische Frage um Klassen realisierung

    Mir ist leider kein guter Titel für mein Vorhaben eingefallen.

    Also ich möchte gerne eine Klasse erstellen die mir nach folgendem Prinzip etwas vom Typ Font zurück gibt

    VB.NET-Quellcode

    1. Dim Arial As New MeineKlasse("Arial")
    2. Dim f As Font = Arial(12).Regular


    Grund dafür ist, das ich nicht ständig

    VB.NET-Quellcode

    1. New Font("Arial", 12, FontStlye.Regular)


    schreiben möchte und auch nicht alle Schriftarten die ich verwenden möchte erst vordefinieren.

    Selbst bin ich soweit gekommen dass ich folgendes Prinzip habe

    VB.NET-Quellcode

    1. Dim f As Font = Arial.Size(12).Regular


    Würde aber wegen der Kürze gerne das .Size wegfallen lassen.
    Font.cls
    Spoiler anzeigen

    VB.NET-Quellcode

    1. Public Class MeineKlasse
    2. Private _fontName As String
    4. Public Sub New(ByVal Fontname As String)
    5. _fontName = Fontname
    6. End Sub
    8. Public Function Size(ByVal Fontsize As Integer) As FontStyle
    9. Return New FontStyle(_fontName, Fontsize)
    10. End Function
    12. Public Class FontStyle
    13. Private _fontName As String
    14. Private _fontSize As Integer
    16. Public Sub New(ByVal Fontname As String, ByVal Fontsize As Integer)
    17. _fontName = Fontname
    18. End Sub
    20. Public ReadOnly Property Bold() As Font
    21. Get
    22. Return New Font(_fontName, _fontSize, FontStyle.Bold)
    23. End Get
    24. End Property
    26. Public ReadOnly Property BoldItalic() As Font
    27. Get
    28. Return New Font(_fontName, _fontSize, FontStyle.BoldItalic)
    29. End Get
    30. End Property
    32. Public ReadOnly Property Italic() As Font
    33. Get
    34. Return New Font(_fontName, _fontSize, FontStyle.Italic)
    35. End Get
    36. End Property
    38. Public ReadOnly Property Regular() As Font
    39. Get
    40. Return New Font(_fontName, _fontSize, FontStyle.Regular)
    41. End Get
    42. End Property
    44. Public ReadOnly Property Strikeout() As XFont
    45. Get
    46. Return New XFont(_fontName, _fontSize, FontStyle.Strikeout)
    47. End Get
    48. End Property
    50. Public ReadOnly Property Underline() As Font
    51. Get
    52. Return New Font(_fontName, _fontSize, FontStyle.Underline)
    53. End Get
    54. End Property
    55. End Class
    56. End Class


    Ich habe mir schon überlegt ob IEnumerable dafür verwendet werden könnte aber ich denke nicht.

    PS: Ich würde gerne genau das Format haben wie ich oben genannt, also nicht sowas

    VB.NET-Quellcode

    1. Dim f As Font = MeineFunktion("Arial", 12).Regular

    Ganz kann ich den Sinn nicht erkennen. Dein Wunsch-Code ganz oben ist länger als die normale Font-Deklaration. Der Fontstyle existiert doch schon als Enum, also warum nochmal sowas austüfteln?
    Was vielleicht Sinn machen würde, wäre die vorhandenen (zu verwendenden) Fontnamen als Enum oder noch besser in einer List(Of T) einmalig anzulegen.
    Sonst wüßt ichs jetz nich besser...Sry
    :thumbsup: Seit 26.Mai 2012 Oppa! :thumbsup:

    VB.NET-Quellcode

    1. Dim Arial As New MeineKlasse("Arial") 'Die Deklaration gehört ja numa dazu
    2. Dim f As Font = Arial(12).Regular 'und dann das hier
    4. Dim f As Font = New Font("Arial", 12, FontStlye.Regular) 'und so isses Standard

    Dann würd ich mir lieber ne Collection an Schriftarten zusamenstellen und dann mit Font_1, Font_2 usw aufrufen (auch gern mit Font(Font_1,12)
    Vielleicht is auch FontFamilywas für dich?
    :thumbsup: Seit 26.Mai 2012 Oppa! :thumbsup:

    Hi,

    wie wäre es mit einem zweckentfremdeten Indexer für "MeineKlasse"?

    VB.NET-Quellcode

    1. Default Public Overloads ReadOnly Property Item(ByVal size As Integer) As FontStyle
    2. Get
    3. Return New FontStyle(_fontName, size)
    4. End Get
    5. End Property


    Damit kannst du Aufrufe wie "Arial(12).Bold" tätigen.
    Hat mit der ursprünglichen Funktion eines Indexers nur bedingt zu tun, aber egal...

    MfG
    Turtle10

    Vatter schrieb:

    VB.NET-Quellcode

    1. Dim Arial As New MeineKlasse("Arial") 'Die Deklaration gehört ja numa dazu
    2. Dim f As Font = Arial(12).Regular 'und dann das hier
    4. Dim f As Font = New Font("Arial", 12, FontStlye.Regular) 'und so isses Standard

    Dann würd ich mir lieber ne Collection an Schriftarten zusamenstellen und dann mit Font_1, Font_2 usw aufrufen (auch gern mit Font(Font_1,12)
    Vielleicht is auch FontFamilywas für dich?

    Naja aber jetzt mal die Anwendung:

    VB.NET-Quellcode

    1. g.DrawString("Text", Arial(12).Regular, Brushes.Black)
    2. g.DrawString("Text2", Arial(9).Regular, Brushes.Black)
    3. g.DrawString("Text3", Arial(10).Bold, Brushes.Black)
    4. g.DrawString("Text4", Arial(7).Regular, Brushes.Black)
    5. g.DrawString("Text5", Arial(13).Regular, Brushes.Black)
    6. g.DrawString("Text5", Arial(11).Regular, Brushes.Black)
    8. ' im gegensatz zu
    10. g.DrawString("Text", New Font("Arial", 12, FontStyles.Regular), Brushes.Black)
    11. g.DrawString("Text2", New Font("Arial", 9, FontStyles.Regular)r, Brushes.Black)
    12. g.DrawString("Text3", New Font("Arial", 10, FontStyles.Bold), Brushes.Black)
    13. g.DrawString("Text4", New Font("Arial", 7, FontStyles.Regular), Brushes.Black)
    14. g.DrawString("Text5", New Font("Arial", 13, FontStyles.Regular), Brushes.Black)
    15. g.DrawString("Text5", New Font("Arial", 11, FontStyles.Regular), Brushes.Black)


    @turtle10: achso vielen Dank, werde ich mal probieren, danke schön.

    Ginge statt dem

    VB.NET-Quellcode

    1. g.DrawString("Text", Arial(12).Regular, Brushes.Black)

    nich auch eine einfache Funktion?

    VB.NET-Quellcode

    1. g.DrawString("Text", Arial(12, Regular), Brushes.Black)

    Is nur ein Kamma statt Punkt und die Klammer eins weiter hinten... :huh:
    :thumbsup: Seit 26.Mai 2012 Oppa! :thumbsup:

    Das würde gehen, aber zum einen siehts nicht so schön aus, wegne Code übersichtlichkeit und zum zweiten was ist mit mehreren Schriftarten??

    VB.NET-Quellcode

    1. Dim Arial As New MeineKlasse("Arial")
    2. Dim Verdana As New MeineKlasse("Verdana")
    3. Dim TimesRoman As New MeineKlasse("Times New Roman")


    Als Funktionen

    VB.NET-Quellcode

    1. Private Function Arial (Size, Style) As Font
    2. Return New Font("Arial", Size, Style)
    3. End Function
    5. Private Function Verdana(Size, Style) As Font
    6. Return New Font("Verdana", Size, Style)
    7. End Function
    9. Private Function TimesRoman(Size, Style) As Font
    10. Return New Font("Times New Roman", Size, Style)
    11. End Function


    Jetzt könnte man noch sagen an EINE Funktion an die man Name, Size und Style übergibt. Klar ginge theoretisch, aber es sieht nicht so schön aus und bei mir soll der Code übersichtlich bleiben, gerade beim DrawString() würden viele Klammern und Anführungszeichen sehr stark die Übersichtlichkeit beeinflussen, deswegen will ich es als eine Art Enum haben.

    Am liebsten sogar so

    VB.NET-Quellcode

    1. Arial.12.Regular


    Aber das geht wohl nicht weil ich die 12 ja auslesen muss.

    Hi
    Machs doch so:

    VB.NET-Quellcode

    1. Public NotInheritable Class FontDescription
    2. Private ffDefaultFontFamily As FontFamily
    3. Private sngDefaultEmSize As Single
    4. Private fsDefaultStyle As FontStyle
    6. Public Sub New(ByVal fontName As String)
    7. ffDefaultFontFamily = New FontFamily(fontName)
    8. End Sub
    10. Public Sub New(ByVal fontName As String, ByVal emSize As Single)
    11. ffDefaultFontFamily = New FontFamily(fontName)
    12. sngDefaultEmSize = emSize
    13. End Sub
    15. Public Sub New(ByVal fontName As String, ByVal emSize As Single, ByVal defaultStyle As FontStyle)
    16. ffDefaultFontFamily = New FontFamily(fontName)
    17. sngDefaultEmSize = emSize
    18. fsDefaultStyle = defaultStyle
    19. End Sub
    21. Public Property DefaultFontFamily() As FontFamily
    22. Get
    23. Return ffDefaultFontFamily
    24. End Get
    25. Set(ByVal value As FontFamily)
    26. ffDefaultFontFamily = value
    27. End Set
    28. End Property
    30. Public Property DefaultEmSize() As Single
    31. Get
    32. Return sngDefaultEmSize
    33. End Get
    34. Set(ByVal value As Single)
    35. sngDefaultEmSize = value
    36. End Set
    37. End Property
    39. Public Property DefaultStyle() As FontStyle
    40. Get
    41. Return fsDefaultStyle
    42. End Get
    43. Set(ByVal value As FontStyle)
    44. fsDefaultStyle = value
    45. End Set
    46. End Property
    48. Public ReadOnly Property DefaultFont() As Font
    49. Get
    50. Return New Font(ffDefaultFontFamily, sngDefaultEmSize, fsDefaultStyle)
    51. End Get
    52. End Property
    54. Default Public ReadOnly Property Font(ByVal emSize As Integer) As Font
    55. Get
    56. Return New Font(ffDefaultFontFamily, emSize, FontStyle.Regular)
    57. End Get
    58. End Property
    60. Default Public ReadOnly Property Font(ByVal emSize As Integer, ByVal style As FontStyle) As Font
    61. Get
    62. Return New Font(ffDefaultFontFamily, emSize, style)
    63. End Get
    64. End Property
    66. Default Public ReadOnly Property Font(ByVal fontName As String, ByVal emDSize As Integer, ByVal style As FontStyle) As Font
    67. Get
    68. Return New Font(fontName, emDSize, style)
    69. End Get
    70. End Property
    72. Default Public ReadOnly Property Font(ByVal fontFamily As FontFamily, ByVal emSize As Integer, ByVal style As FontStyle) As Font
    73. Get
    74. Return New Font(fontFamily, emSize, style)
    75. End Get
    76. End Property
    77. End Class


    Arial.12.Regular ist auf herkömmlichem Weg nicht möglich (und auch nicht zu empfehlen).

    Gruß
    ~blaze~

    Schau mal, ob das etwas für dich ist: (Obwohl ich die Standard-Methode nicht unübersichtlich finde...)
    Spoiler anzeigen


    VB.NET-Quellcode

    1. Imports System.Runtime.CompilerServices
    3. Public Class Form1
    4. Private Sub PictureBox1_Paint(ByVal sender As Object, ByVal e As System.Windows.Forms.PaintEventArgs) Handles PictureBox1.Paint
    7. Dim g As Graphics = e.Graphics
    10. Dim fnt As Font = Font.CreateFont
    12. g.DrawString("laangerText", fnt.tofont("Wingdings"), Brushes.Black, New Point(29, 43))
    13. ' jetzt in Größe 23
    14. g.DrawString("grooßer Text", fnt.toSize(23), Brushes.Pink, New Point(9, 6))
    16. 'jetzt totaler Mix
    17. g.DrawString("Mix", fnt.toStrikeout.toSize(135), Brushes.Green, New Point(14, 14))
    18. g.DrawString("Re-Mix", fnt.toBold.toSize(148), Brushes.Red, New Point(46, 16))
    19. g.DrawString("Edit", fnt.toItalic.toSize(128), Brushes.Pink, New Point(88, 18))
    21. 'Alles zusammen:
    22. g.DrawString("(c) 2011 der_Kurt", fnt.tofont("tahoma").toItalic.toSize(18).toBold.toStrikeout, Brushes.Black, New Point(100, 350))
    24. '****************************************
    25. '****************************************
    26. '** BTW: Das ist die Standarddefinition, die ich kein bißchen unübersichtlich finde...
    27. g.DrawString("text2", _
    28. New Font("Arial", 9, FontStyle.Regular), _
    29. Brushes.Black, _
    30. New PointF(29, 39))
    32. End Sub
    33. End Class


    VB.NET-Quellcode

    1. Module gfx_erweiterung
    3. Dim theFont As Font
    4. Dim defaultsize As Single = 8
    5. Dim defaultFontstyle As FontStyle = FontStyle.Regular
    6. Dim defaultfont As New Font("Arial", defaultsize, defaultFontstyle)
    8. <Extension()> Function CreateFont(ByVal fnt As Font) As Font
    9. Return defaultfont
    10. End Function
    12. <Extension()> Public Function toRegular(ByVal fnt As Font) As Font
    13. Return New Font(fnt.FontFamily, fnt.Size, fnt.Style Or FontStyle.Regular)
    14. End Function
    16. <Extension()> Public Function toItalic(ByVal fnt As Font) As Font
    17. Return New Font(fnt.FontFamily, fnt.Size, fnt.Style Or FontStyle.Italic)
    18. End Function
    20. <Extension()> Public Function toStrikeout(ByVal fnt As Font) As Font
    21. Return New Font(fnt.FontFamily, fnt.Size, fnt.Style Or FontStyle.Strikeout)
    22. End Function
    24. <Extension()> Public Function toBold(ByVal fnt As Font) As Font
    25. Return New Font(fnt.FontFamily, fnt.Size, fnt.Style Or FontStyle.Bold)
    26. End Function
    28. <Extension()> Function toSize(ByVal fnt As Font, ByVal size As Single) As Font
    29. Return New Font(fnt.FontFamily, size, fnt.Style)
    30. End Function
    32. <Extension()> Function tofont(ByVal fnt As Font, ByVal newfont As String) As Font
    33. Dim newfontfamily As New FontFamily(newfont)
    34. Return New Font(newfontfamily, defaultsize)
    35. End Function
    36. End Module


    Ich empfehle noch Fehlerbehandlung (falls der Font nicht existiert). Code nur kurz getestet, sollte aber funktionieren.

    LG, Kurti

    Hi Dodo,
    nachdem ich nun (glaub ich) endlich verstanden hab, was du willst, werde ich mich nun ein letztes mal blamieren mit folgendem simplen Vorschlag:
    Spoiler anzeigen

    VB.NET-Quellcode

    1. Public Class MeineSchrift
    2. Private _name As String
    3. Sub New(ByVal Name As String)
    4. _name = Name
    5. End Sub
    7. Public ReadOnly Property Bold(ByVal Size As Integer) As Font
    8. Get
    9. Return New Font(_name, Size, FontStyle.Bold)
    10. End Get
    11. End Property
    13. Public ReadOnly Property Italic(ByVal Size As Integer) As Font
    14. Get
    15. Return New Font(_name, Size, FontStyle.Italic)
    16. End Get
    17. End Property
    19. Public ReadOnly Property Regular(ByVal Size As Integer) As Font
    20. Get
    21. Return New Font(_name, Size, FontStyle.Regular)
    22. End Get
    23. End Property
    24. 'usw. usw.
    25. End Class


    Und Aufruf mit z.B.:

    VB.NET-Quellcode

    1. Dim Arial as new MeineSchrift("Arial")
    2. e.Graphics.DrawString("Hallo Schrift!", Arial.Bold(12), Brushes.Black, 20, 20)

    das kommt doch dem schon sehr nahe, was du willst oder? :rolleyes:
    :thumbsup: Seit 26.Mai 2012 Oppa! :thumbsup:

    Hallo,

    ja das kommt dem schon nah und sicher, wieso bin ich nicht auf diese Idee gekommen die Size einfach hinten mit anzugeben?
    Ich war so fixiert auf die Instanzierung der normalen Font wo erst Fontname, Size und Style angegeben wird das ich diese Reihenfolge beibehalten wollte.

    Ich denke mal ich werde deine Methode übernehmen. Vielen Dank nochmal an alle!

Facebook
Telefonspende