Graduierungen BestPractice, oder wie gestalte ich dies am Besten

  • C#

Es gibt 28 Antworten in diesem Thema. Der letzte Beitrag () ist von Nofear23m.

    Graduierungen BestPractice, oder wie gestalte ich dies am Besten

    Hallo,
    ich erstelle gerade eine Anwendung für das Dojo in dem ich trainiere. (Japanische Kampfkunst).
    Nun bin ich gerade dabei, die Graduierungen zu implementieren.
    Da mein Trainer nicht viel einstellen will, sollte es am Ende so sein, das man lediglich eine Combobox mit der Japanischen Bezeichnung der Graduierung hat und der Rest (Gürtelfarbe, Grad der Graduierung, Sterne usw.) im Hintergund automatisch eingestellt wird.
    Weiter unten findet Ihr eine Tabelle der Graduierungen.
    Nun stellt sich mir die Frage, wie ich das am Besten angehe.
    Ich dachte erst an verschiedene Enums, müsste diese aber dann ja irgendwie zusammenführen.
    Dann dachte ich an eine eigene Tabelle, da stellt sich mir aber dann die Frage, wie ich dann mittels 1 Combobox die Graduierung einstelle und die Daten dann selbst geschrieben werden.

    Zur Veranschaulichung hier mal die Enums, die ich erstellt habe, es sind 3 Stück.
    1 Enum für die Schüler Graduierungen
    1 Enum für die Meister Graduierungen und
    1 Enum für die Gürtelfarben (es gibt nur 4 Farben, weiß, Rot/Grün (wobei Rot bei Frauen und Grün bei Männern und Schwarz).

    Es gibt darüberhinaus aber noch einige weitere Punkte, diese sind nicht zwingend, aber für die Übersicht nachher in der App, wäre es schön, dadurch zum Beispiel die Schriftfarbe oder so einstellen zu können.

    SchülerGraduierung:

    C#-Quellcode

    1. public enum KyūGraduationEnum
    2. {
    3. None = 0,
    4. //weiss
    5. mukyū = 10,
    6. // rot/grün
    7. kyūkyū = 9,
    8. hachikyū = 8,
    9. nanakyū = 7,
    10. rokukyū = 6,
    11. gokyū = 5,
    12. yonkyū = 4,
    13. sankyū = 3,
    14. nikyū = 2,
    15. ichikyū = 1,
    16. }


    Meister Graduierung:

    C#-Quellcode

    1. // schwarz
    2. public enum DanGraduationEnum
    3. {
    4. None = 0,
    5. shodan = 1,
    6. nidan = 2,
    7. sandan = 3,
    8. yondan = 4,
    9. godan = 5,
    10. rokudan = 6,
    11. nanadan = 7,
    12. hachidan = 8,
    13. kyūdan = 9,
    14. jūdan = 10,
    15. chigyo = 11,
    16. suigyo = 12,
    17. kagyo = 13,
    18. fugyo = 14,
    19. kugyo = 15
    20. }


    und die Gürtelfarben:

    C#-Quellcode

    1. public enum BeltColorEnum
    2. {
    3. Weiß,
    4. Rot,
    5. Grün,
    6. Schwarz
    7. }


    Alternativ hier die Graduation Klasse:
    Spoiler anzeigen

    C#-Quellcode

    1. public class Graduation : ModelBase
    2. {
    3. public virtual int Degree { get; set; }
    4. //Hier fehlt jetzt der japanische Name, da es aber ja 2 Enums sind....
    5. // die Grade sind ja auch doppelt vorhanden, 1 mal von 10 bis 1 und einmal von 1 bis 15
    6. public virtual string Character { get; set; }
    7. public virtual BorderColorEnum BorderColor { get; set; }
    8. public virtual BackgroundColorEnum BackgroundColor { get; set; }
    9. public virtual StarColorEnum StarColor { get; set; }
    10. public virtual int StarCount { get; set; }
    11. public virtual int PersonId { get; set; }
    12. public virtual Person Person { get; set; }
    13. }
    14. public enum KyūGraduationEnum
    15. {
    16. None = 0,
    17. //weiss
    18. mukyū = 10,
    19. // rot/grün
    20. kyūkyū = 9,
    21. hachikyū = 8,
    22. nanakyū = 7,
    23. rokukyū = 6,
    24. gokyū = 5,
    25. yonkyū = 4,
    26. sankyū = 3,
    27. nikyū = 2,
    28. ichikyū = 1,
    29. }
    30. // schwarz
    31. public enum DanGraduationEnum
    32. {
    33. None = 0,
    34. shodan = 1,
    35. nidan = 2,
    36. sandan = 3,
    37. yondan = 4,
    38. godan = 5,
    39. rokudan = 6,
    40. nanadan = 7,
    41. hachidan = 8,
    42. kyūdan = 9,
    43. jūdan = 10,
    44. chigyo = 11,
    45. suigyo = 12,
    46. kagyo = 13,
    47. fugyo = 14,
    48. kugyo = 15
    49. }
    50. public enum BeltColorEnum
    51. {
    52. Weiß,
    53. Rot,
    54. Grün,
    55. Schwarz
    56. }
    57. public enum BorderColorEnum
    58. {
    59. White,
    60. Black,
    61. Silver,
    62. LightBlue,
    63. }
    64. public enum BackgroundColorEnum
    65. {
    66. Red,
    67. Orange
    68. }
    69. public enum StarColorEnum
    70. {
    71. None,
    72. Silver,
    73. Gold
    74. }


    Wie gehe ich da am besten vor?
    Wire gesagt, es soll nachher in der Anlage eines Mitglieds nur eine Combobox zur Auswahl des japanischen Namen geben und dennoch alle Einstellungen der Graduierung gesetzt werden.

    Hier noch die Tabelle:

    Danke Euch
    "Hier könnte Ihre Werbung stehen..."
    Ich denke hier wäre ein (typisiertes DataSet) das Mittel meiner Wahl.
    Es gibt hier im Forum wunderbare Tutorials dazu vom @ErfinderDesRades .
    Diese sind allerdings - soweit ich weiß - alle in Visual Basic. Vielleicht hilft es dir ja trotzdem.
    die vier Views auf Video
    Auch die Youtube Videos dazu sind absolut sehenswert.
    Hi @DerSmurf,
    Danke für deinen Hinweis, allerdings geht es nicht darum, die Daten weg zu schreiben, das passiert ja schon. Ich arbeite hier mit WPF und EntityFramework Core und SQLite.
    Mir geht es darum, zu begreifen, wie ich die Graduierung am sinnvollsten gestalte, sodass der Benutzer des Programms (mein Trainer) nicht 10 verschiedene Dinge zum Mitglied eintragen muss.
    Die ganzen neben Details einer Graduierung ergeben sich ja aus dem Namen der Graduierung.
    Hier ist aber bereits das Problem, das die Grade der Graduierung ja dopplet sind, nämlich von 10 bis 1 und von 1 bis 15, somit kann ich die Graduierungen nicht in 1 Enum darstellen.

    Vielleicht als Beispiel:
    Der Trainer, öffnet das Programm, erstellt ein neus Mitglied.
    Er gibt Vorname, Nachname und Eintrittsdatum ein, wählt dann die Gruppe aus zu dem das Mitglied gehört (Erwachsene oder Kids) und wählt dann die Graduierung (zum Beispiel nikyū)
    dann ergäbe sich aus dem namen nikyū der Schüler Grad 2, die Gürtelfarbe Grün bei männlich und rot bei weiblich, Schriftzeichen und Rand müssten dann in weiß eingestellt werden, die Hintergundfarbe in rot, die Sterne Anzahl ist 3 und die Sternfarbe ist Gold. Wobei die Farben und Sterne nur Nebensächlich wären...
    der Trainer wählt also aus der Combobox nikyū aus und der Rest wird automatisch gespeichert.
    "Hier könnte Ihre Werbung stehen..."
    Die Enums kannst Du bestimmt verwenden, musst aber m.E. trotzdem eine Zuordnungstabelle kreieren, die dann eben quasi Verweise auf die Enums macht. Ohne geht's nicht. Die Tabelle bindest Du an die ComboBox und lässt da eben nur den Grad anzeigen. Der Trainer muss aber dann neben der Altersgruppe eben noch das Geschlecht wählen.
    Dieser Beitrag wurde bereits 5 mal editiert, zuletzt von „VaporiZed“, mal wieder aus Grammatikgründen.

    Häufig von mir verwendete Abkürzungen: CEs = control elements (Labels, Buttons, DGVs, ...) und tDS (typisiertes DataSet)
    Aufgrund spontaner Selbsteintrübung sind all meine Glaskugeln beim Hersteller. Lasst mich daher bitte nicht in den Spekulatiusmodus gehen.
    Jo, da muss eine kleine Klasse für her, allerdings iwie anners als dein Ansatz.
    Also die Klasse muss wirklich eine Graduierung modellieren - nix anners:
    Name, Gürtelfarbe, Sternchen, SternchenFarbe und so Kram muss da rein, halt alles, was genau zu einem Grad gehört.

    Ja - genau die Spalten der Wiki-Tabelle - das ist der Datensatz, den du brauchst.
    Und von diesen Datensätzen musste halt genausoviele anlegen, wie die Wiki-Tabelle Zeilen hat.

    Zu Farben etc. kann man überlegen, ob man da ein Enum zwischenschieben will, oder einfach stracks einen FarbCode hinmacht.

    An deim Ansatz scheint mir nicht zu passen, dass da von Character, Person, PersonId die Rede ist. Solch gehört natürlich nicht in die Grad-Entität, sondern evtl. in eine Person-Entität.
    Hallo @ErfinderDesRades
    Ich hab gestern noch einige Zeit daran rum gebastelt und meine Klasse Graduierung so aufgebaut wie die Wiki Tabelle.
    In der Person Klasse hab ich ein Property vom Typ Graduierung.
    Nun hab ich allerdings noch das Problem, das ich ja irgendwie über eine Auswahl in der View die richtige Graduierung aus der DB laden muss,
    dazu bräuchte ich doch ein enum um das auszuwählen.
    Allerdings reicht ja ein Enum nicht, weil es ja 2 "Abteilungen" der Graduierung gibt, nämlich einmal die Schüler Graduierung von 10 (nierdigster Grad) bis 1 (höchster Grad) und einmal die Meister Graduierung (ab schwarzer Gürtel) von 1 (niedrigster Grad) bis 15 (höchster Grad) auch Dan genannt.
    Die Datenbankl besteht ja am Anfang noch nicht, sondern wird mit EnsureCreated beim Start erstellt.
    Da könnte ich dann eine Seed Methode einbauen, die die Graduierungen anlegt.
    Ich müsste dann die 3 Enumse (Member Graduation um auszuwählen ob es Schüler oder Meister ist), das Schüler Enum (um auszuwählen welcher Grad der Schüler hat (bzw. der japanische Name des Grads)) und das Meister Enum.
    Diese Enumse müssten dann wohl eher in die Person Klasse, richtig?

    ich hab hier mal die beiden Klassen:
    Die Graduierung:
    Spoiler anzeigen

    C#-Quellcode

    1. public class Graduation : ModelBase
    2. {
    3. /// <summary>
    4. /// der Grad der Graduierung (Schüler = 10 - 1, Meister = 1 - 15)
    5. /// </summary>
    6. public virtual int Degree { get; set; }
    7. /// <summary>
    8. /// Japanischer Name der Graduierung (ergibt sich aus dem entsprechenden Enum)
    9. /// </summary>
    10. public virtual string Name { get; set; }
    11. /// <summary>
    12. /// Enum für die Gürtelfarbe (weiß, Rot/Grün, Schwarz)
    13. /// Rot/Grün ab Schüler Grad 9, Rot für Frauen, Grün für Männer
    14. /// Schwarz ab Meistergrad 1
    15. /// </summary>
    16. public virtual BeltColorEnum BeltColor { get; set; }
    17. /// <summary>
    18. /// Enum für die Schriftfarbe, die Schriftfarbe, der Rand und die Hintergurndfarbe beschreiben das Patch
    19. /// auf dem Anzug
    20. /// </summary>
    21. public virtual FontColorEnum FontColor { get; set; }
    22. public virtual BorderColorEnum BorderColor { get; set; }
    23. public virtual BackgroundColorEnum BackgroundColor { get; set; }
    24. /// <summary>
    25. /// Enum für die Farbe der Sterne, Silber, Gold
    26. /// </summary>
    27. public virtual StarColorEnum StarColor { get; set; }
    28. /// <summary>
    29. /// Anzahl der Sterne, abhängig von der Graduierung
    30. /// </summary>
    31. public virtual int StarCount { get; set; }
    32. }
    33. public enum BeltColorEnum
    34. {
    35. White,
    36. Red,
    37. Green,
    38. Black
    39. }
    40. public enum FontColorEnum
    41. {
    42. White = 0,
    43. Black = 2,
    44. Silver = 4,
    45. Green = 6,
    46. LightBlue = 8,
    47. }
    48. public enum BorderColorEnum
    49. {
    50. White,
    51. Black,
    52. Silver,
    53. LightBlue,
    54. }
    55. public enum BackgroundColorEnum
    56. {
    57. Red,
    58. Orange
    59. }
    60. public enum StarColorEnum
    61. {
    62. None,
    63. Silver,
    64. Gold
    65. }


    und die Person Klasse:
    Spoiler anzeigen

    C#-Quellcode

    1. public class Person : ModelBase
    2. {
    3. [Required(AllowEmptyStrings = false, ErrorMessage = "Bitte geben sie einen Vornamen an")]
    4. [MinLength(3)]
    5. [MaxLength(150)]
    6. public virtual string FirstName { get; set; }
    7. [Required(AllowEmptyStrings = false, ErrorMessage = "Bitte geben sie einen Nachnamen an")]
    8. [MinLength(3)]
    9. [MaxLength(150)]
    10. public virtual string LastName { get; set; }
    11. public virtual LoginData AcessData { get; set; }
    12. public virtual string FullName => $"{LastName}, {FirstName}";
    13. public virtual DateTime EntryDate { get; set; } = DateTime.Today;
    14. public virtual GenderEnum Gender { get; set; } = GenderEnum.männlich;
    15. public virtual PersonTypeEnum PersonType { get; set; } = PersonTypeEnum.Shinzan;
    16. public virtual Graduation Graduation { get; set; }
    17. public virtual GraduationEnum MemberGraduation { get; set; }
    18. /// <summary>
    19. /// Ein Enum für die Schüler Graduierung
    20. /// </summary>
    21. public virtual KyūGraduationEnum StudentGraduation { get; set; }
    22. /// <summary>
    23. /// Ein Enum für die Meister Graduierung (Schwarzer Gürtel, Dan 1 - 15)
    24. /// </summary>
    25. public virtual DanGraduationEnum MasterGraduation { get; set; }
    26. public virtual bool IsAdmin { get; set; } = false;
    27. }
    28. public enum GenderEnum
    29. {
    30. männlich,
    31. weiblich
    32. }
    33. public enum PersonTypeEnum
    34. {
    35. Shinzan,
    36. ShinzanKids
    37. }
    38. public enum GraduationEnum
    39. {
    40. Student,
    41. Master
    42. }
    43. /// <summary>
    44. /// Schüler Grad weißer, rot oder grüner Gürtel
    45. /// </summary>
    46. public enum KyūGraduationEnum
    47. {
    48. None = 0,
    49. //weiss
    50. mukyū = 10,
    51. // rot/grün
    52. kyūkyū = 9,
    53. hachikyū = 8,
    54. nanakyū = 7,
    55. rokukyū = 6,
    56. gokyū = 5,
    57. yonkyū = 4,
    58. sankyū = 3,
    59. nikyū = 2,
    60. ichikyū = 1,
    61. }
    62. /// <summary>
    63. /// Meister Grad (schwarzer Gürtel)
    64. /// </summary>
    65. public enum DanGraduationEnum
    66. {
    67. None = 0,
    68. shodan = 1,
    69. nidan = 2,
    70. sandan = 3,
    71. yondan = 4,
    72. godan = 5,
    73. rokudan = 6,
    74. nanadan = 7,
    75. hachidan = 8,
    76. kyūdan = 9,
    77. jūdan = 10,
    78. chigyo = 11,
    79. suigyo = 12,
    80. kagyo = 13,
    81. fugyo = 14,
    82. kugyo = 15
    83. }


    Wobei, wenn ich recht überlege, dann brauch ich die Enums ja lediglich im Viewmodel um die Auswahl zu treffen und die Graduierung kann ich ja dann anhand des Names raus suchen und der Person zuordnen.
    Ich versuch mal, die Seed Methode zu basteln um die Graduierungen in die DB zu schreiben bei Programmstart...
    "Hier könnte Ihre Werbung stehen..."
    Hallo,
    So, ich hab nun die Klasse Graduation angepasst.
    Spoiler anzeigen

    C#-Quellcode

    1. public class Graduation : ModelBase
    2. {
    3. /// <summary>
    4. /// der Grad der Graduierung (Schüler = 10 - 1, Meister = 1 - 15)
    5. /// </summary>
    6. public virtual int Degree { get; set; }
    7. /// <summary>
    8. /// Japanischer Name der Graduierung (ergibt sich aus dem entsprechenden Enum)
    9. /// </summary>
    10. public virtual string Name { get; set; }
    11. /// <summary>
    12. /// Enum für die übergeordnete Graduierung (Student oder Master)
    13. /// um später im View zu gruppieren
    14. /// </summary>
    15. public virtual GraduationEnum MemberGraduation { get; set; }
    16. /// <summary>
    17. /// Enum für die Gürtelfarbe (weiß, Rot/Grün, Schwarz)
    18. /// Rot/Grün ab Schüler Grad 9, Rot für Frauen, Grün für Männer
    19. /// Schwarz ab Meistergrad 1
    20. /// </summary>
    21. public virtual BeltColorEnum BeltColor { get; set; }
    22. /// <summary>
    23. /// Enum für die Schriftfarbe, die Schriftfarbe, der Rand und die Hintergurndfarbe beschreiben das Patch
    24. /// auf dem Anzug
    25. /// </summary>
    26. public virtual FontColorEnum FontColor { get; set; }
    27. public virtual BorderColorEnum BorderColor { get; set; }
    28. public virtual BackgroundColorEnum BackgroundColor { get; set; }
    29. /// <summary>
    30. /// Enum für die Farbe der Sterne, Silber, Gold
    31. /// </summary>
    32. public virtual StarColorEnum StarColor { get; set; }
    33. /// <summary>
    34. /// Anzahl der Sterne, abhängig von der Graduierung
    35. /// </summary>
    36. public virtual int StarCount { get; set; }
    37. public override string ToString()
    38. {
    39. return $"{Name} - Grad {Degree}";
    40. }
    41. }
    42. public enum GraduationEnum
    43. {
    44. Student,
    45. Master
    46. }
    47. /// <summary>
    48. /// Schüler Grad weißer, rot oder grüner Gürtel
    49. /// </summary>
    50. public enum KyūGraduationEnum
    51. {
    52. //weiss
    53. mukyū = 10,
    54. // rot/grün
    55. kyūkyū = 9,
    56. hachikyū = 8,
    57. nanakyū = 7,
    58. rokukyū = 6,
    59. gokyū = 5,
    60. yonkyū = 4,
    61. sankyū = 3,
    62. nikyū = 2,
    63. ichikyū = 1,
    64. }
    65. /// <summary>
    66. /// Meister Grad (schwarzer Gürtel)
    67. /// </summary>
    68. public enum DanGraduationEnum
    69. {
    70. shodan = 1,
    71. nidan = 2,
    72. sandan = 3,
    73. yondan = 4,
    74. godan = 5,
    75. rokudan = 6,
    76. nanadan = 7,
    77. hachidan = 8,
    78. kyūdan = 9,
    79. jūdan = 10,
    80. chigyo = 11,
    81. suigyo = 12,
    82. kagyo = 13,
    83. fugyo = 14,
    84. kugyo = 15
    85. }
    86. public enum BeltColorEnum
    87. {
    88. White,
    89. Red,
    90. Green,
    91. RedGreen,
    92. Black
    93. }
    94. public enum FontColorEnum
    95. {
    96. White = 0,
    97. Black = 2,
    98. Silver = 4,
    99. Green = 6,
    100. LightBlue = 8,
    101. }
    102. public enum BorderColorEnum
    103. {
    104. White,
    105. Black,
    106. Silver,
    107. LightBlue,
    108. }
    109. public enum BackgroundColorEnum
    110. {
    111. Red,
    112. Orange
    113. }
    114. public enum StarColorEnum
    115. {
    116. None,
    117. Silver,
    118. Gold
    119. }


    im Person Model hab ich weiterhin das Property Graduation:
    Spoiler anzeigen

    C#-Quellcode

    1. public class Person : ModelBase
    2. {
    3. [Required(AllowEmptyStrings = false, ErrorMessage = "Bitte geben sie einen Vornamen an")]
    4. [MinLength(3)]
    5. [MaxLength(150)]
    6. public virtual string FirstName { get; set; }
    7. [Required(AllowEmptyStrings = false, ErrorMessage = "Bitte geben sie einen Nachnamen an")]
    8. [MinLength(3)]
    9. [MaxLength(150)]
    10. public virtual string LastName { get; set; }
    11. public virtual LoginData AcessData { get; set; }
    12. public virtual string FullName => $"{LastName}, {FirstName}";
    13. public virtual DateTime EntryDate { get; set; } = DateTime.Today;
    14. public virtual GenderEnum Gender { get; set; } = GenderEnum.male;
    15. public virtual PersonTypeEnum PersonType { get; set; } = PersonTypeEnum.Shinzan;
    16. public virtual Graduation Graduation { get; set; }
    17. public virtual bool IsAdmin { get; set; } = false;
    18. }
    19. public enum GenderEnum
    20. {
    21. male,
    22. female
    23. }
    24. public enum PersonTypeEnum
    25. {
    26. Shinzan,
    27. ShinzanKids
    28. }


    Dann hab ich eine Seed Methode erstellt um die ganzen Graduierungen einzutragen:
    Spoiler anzeigen

    C#-Quellcode

    1. public static void Seed()
    2. {
    3. using (var prov = new GraduationProvider())
    4. {
    5. foreach (var degree in GetStudentGraduations())
    6. {
    7. var studentGraduation = new Graduation();
    8. studentGraduation.FontColor = FontColorEnum.White;
    9. studentGraduation.BorderColor = BorderColorEnum.White;
    10. studentGraduation.BackgroundColor = BackgroundColorEnum.Red;
    11. studentGraduation.Degree = (int)degree;
    12. studentGraduation.Name = degree.ToString();
    13. studentGraduation.MemberGraduation = GraduationEnum.Student;
    14. switch (degree)
    15. {
    16. case KyūGraduationEnum.mukyū:
    17. studentGraduation.BeltColor = BeltColorEnum.White;
    18. studentGraduation.StarCount = 0;
    19. break;
    20. case KyūGraduationEnum.kyūkyū:
    21. studentGraduation.BeltColor = BeltColorEnum.RedGreen;
    22. studentGraduation.StarCount = 0;
    23. break;
    24. case KyūGraduationEnum.hachikyū:
    25. studentGraduation.BeltColor = BeltColorEnum.RedGreen;
    26. studentGraduation.StarCount = 1;
    27. studentGraduation.StarColor = StarColorEnum.Silver;
    28. break;
    29. case KyūGraduationEnum.nanakyū:
    30. studentGraduation.BeltColor = BeltColorEnum.RedGreen;
    31. studentGraduation.StarCount = 2;
    32. studentGraduation.StarColor = StarColorEnum.Silver;
    33. break;
    34. case KyūGraduationEnum.rokukyū:
    35. studentGraduation.BeltColor = BeltColorEnum.RedGreen;
    36. studentGraduation.StarCount = 3;
    37. studentGraduation.StarColor = StarColorEnum.Silver;
    38. break;
    39. case KyūGraduationEnum.gokyū:
    40. studentGraduation.BeltColor = BeltColorEnum.RedGreen;
    41. studentGraduation.StarCount = 4;
    42. studentGraduation.StarColor = StarColorEnum.Silver;
    43. break;
    44. case KyūGraduationEnum.yonkyū:
    45. studentGraduation.BeltColor = BeltColorEnum.RedGreen;
    46. studentGraduation.StarCount = 1;
    47. studentGraduation.StarColor = StarColorEnum.Gold;
    48. break;
    49. case KyūGraduationEnum.sankyū:
    50. studentGraduation.BeltColor = BeltColorEnum.RedGreen;
    51. studentGraduation.StarCount = 2;
    52. studentGraduation.StarColor = StarColorEnum.Gold;
    53. break;
    54. case KyūGraduationEnum.nikyū:
    55. studentGraduation.BeltColor = BeltColorEnum.RedGreen;
    56. studentGraduation.StarCount = 2;
    57. studentGraduation.StarColor = StarColorEnum.Gold;
    58. break;
    59. case KyūGraduationEnum.ichikyū:
    60. studentGraduation.BeltColor = BeltColorEnum.RedGreen;
    61. studentGraduation.StarCount = 4;
    62. studentGraduation.StarColor = StarColorEnum.Gold;
    63. break;
    64. }
    65. prov.Insert(studentGraduation);
    66. }
    67. foreach (var degree in GetMasterGraduations())
    68. {
    69. var masterGraduation = new Graduation();
    70. masterGraduation.Degree = (int)degree;
    71. masterGraduation.BeltColor = BeltColorEnum.Black;
    72. masterGraduation.Name = degree.ToString();
    73. masterGraduation.MemberGraduation = GraduationEnum.Master;
    74. switch (degree)
    75. {
    76. case DanGraduationEnum.shodan:
    77. masterGraduation.FontColor = FontColorEnum.Black;
    78. masterGraduation.BorderColor = BorderColorEnum.Black;
    79. masterGraduation.BackgroundColor = BackgroundColorEnum.Red;
    80. masterGraduation.StarCount = 0;
    81. break;
    82. case DanGraduationEnum.nidan:
    83. masterGraduation.FontColor = FontColorEnum.Black;
    84. masterGraduation.BorderColor = BorderColorEnum.Black;
    85. masterGraduation.BackgroundColor = BackgroundColorEnum.Red;
    86. masterGraduation.StarCount = 1;
    87. masterGraduation.StarColor = StarColorEnum.Silver;
    88. break;
    89. case DanGraduationEnum.sandan:
    90. masterGraduation.FontColor = FontColorEnum.Black;
    91. masterGraduation.BorderColor = BorderColorEnum.Black;
    92. masterGraduation.BackgroundColor = BackgroundColorEnum.Red;
    93. masterGraduation.StarCount = 2;
    94. masterGraduation.StarColor = StarColorEnum.Silver;
    95. break;
    96. case DanGraduationEnum.yondan:
    97. masterGraduation.FontColor = FontColorEnum.Black;
    98. masterGraduation.BorderColor = BorderColorEnum.Black;
    99. masterGraduation.BackgroundColor = BackgroundColorEnum.Red;
    100. masterGraduation.StarCount = 3;
    101. masterGraduation.StarColor = StarColorEnum.Silver;
    102. break;
    103. case DanGraduationEnum.godan:
    104. masterGraduation.FontColor = FontColorEnum.Black;
    105. masterGraduation.BorderColor = BorderColorEnum.Silver;
    106. masterGraduation.BackgroundColor = BackgroundColorEnum.Red;
    107. masterGraduation.StarCount = 0;
    108. break;
    109. case DanGraduationEnum.rokudan:
    110. masterGraduation.FontColor = FontColorEnum.Black;
    111. masterGraduation.BorderColor = BorderColorEnum.Silver;
    112. masterGraduation.BackgroundColor = BackgroundColorEnum.Red;
    113. masterGraduation.StarCount = 1;
    114. masterGraduation.StarColor = StarColorEnum.Gold;
    115. break;
    116. case DanGraduationEnum.nanadan:
    117. masterGraduation.FontColor = FontColorEnum.Black;
    118. masterGraduation.BorderColor = BorderColorEnum.Silver;
    119. masterGraduation.BackgroundColor = BackgroundColorEnum.Red;
    120. masterGraduation.StarCount = 2;
    121. masterGraduation.StarColor = StarColorEnum.Gold;
    122. break;
    123. case DanGraduationEnum.hachidan:
    124. masterGraduation.FontColor = FontColorEnum.Black;
    125. masterGraduation.BorderColor = BorderColorEnum.Silver;
    126. masterGraduation.BackgroundColor = BackgroundColorEnum.Red;
    127. masterGraduation.StarCount = 3;
    128. masterGraduation.StarColor = StarColorEnum.Gold;
    129. break;
    130. case DanGraduationEnum.kyūdan:
    131. masterGraduation.FontColor = FontColorEnum.Black;
    132. masterGraduation.BorderColor = BorderColorEnum.Silver;
    133. masterGraduation.BackgroundColor = BackgroundColorEnum.Red;
    134. masterGraduation.StarCount = 4;
    135. masterGraduation.StarColor = StarColorEnum.Gold;
    136. break;
    137. case DanGraduationEnum.jūdan:
    138. masterGraduation.FontColor = FontColorEnum.Green;
    139. masterGraduation.BorderColor = BorderColorEnum.LightBlue;
    140. masterGraduation.BackgroundColor = BackgroundColorEnum.Orange;
    141. masterGraduation.StarCount = 0;
    142. break;
    143. case DanGraduationEnum.chigyo:
    144. masterGraduation.FontColor = FontColorEnum.Green;
    145. masterGraduation.BorderColor = BorderColorEnum.LightBlue;
    146. masterGraduation.BackgroundColor = BackgroundColorEnum.Orange;
    147. masterGraduation.StarCount = 1;
    148. masterGraduation.StarColor = StarColorEnum.Gold;
    149. break;
    150. case DanGraduationEnum.suigyo:
    151. masterGraduation.FontColor = FontColorEnum.Green;
    152. masterGraduation.BorderColor = BorderColorEnum.LightBlue;
    153. masterGraduation.BackgroundColor = BackgroundColorEnum.Orange;
    154. masterGraduation.StarCount = 2;
    155. masterGraduation.StarColor = StarColorEnum.Gold;
    156. break;
    157. case DanGraduationEnum.kagyo:
    158. masterGraduation.FontColor = FontColorEnum.Green;
    159. masterGraduation.BorderColor = BorderColorEnum.LightBlue;
    160. masterGraduation.BackgroundColor = BackgroundColorEnum.Orange;
    161. masterGraduation.StarCount = 3;
    162. masterGraduation.StarColor = StarColorEnum.Gold;
    163. break;
    164. case DanGraduationEnum.fugyo:
    165. masterGraduation.FontColor = FontColorEnum.Green;
    166. masterGraduation.BorderColor = BorderColorEnum.LightBlue;
    167. masterGraduation.BackgroundColor = BackgroundColorEnum.Orange;
    168. masterGraduation.StarCount = 4;
    169. masterGraduation.StarColor = StarColorEnum.Gold;
    170. break;
    171. case DanGraduationEnum.kugyo:
    172. masterGraduation.FontColor = FontColorEnum.Green;
    173. masterGraduation.BorderColor = BorderColorEnum.LightBlue;
    174. masterGraduation.BackgroundColor = BackgroundColorEnum.Orange;
    175. masterGraduation.StarCount = 5;
    176. masterGraduation.StarColor = StarColorEnum.Gold;
    177. break;
    178. }
    179. prov.Insert(masterGraduation);
    180. }
    181. }
    182. }
    183. public static IEnumerable<KyūGraduationEnum> GetStudentGraduations()
    184. {
    185. return Enum.GetValues(typeof(KyūGraduationEnum)).OfType<KyūGraduationEnum>().Reverse();
    186. }
    187. public static IEnumerable<DanGraduationEnum> GetMasterGraduations()
    188. {
    189. return Enum.GetValues(typeof(DanGraduationEnum)).OfType<DanGraduationEnum>();
    190. }


    Das klappt soweit auch alles gut.

    im PersonDetailViewModel erstelle ich eine Liste aller Graduierungen und Binde diese an eine ComboBox, das SelectedItem der Combobox wird dann an eine einzelne Graduation gebunden:

    C#-Quellcode

    1. public List<Graduation> Graduations => GraduationLogic.GetGraduations();
    2. private Graduation _selectedGraduation;
    3. public Graduation SelectedGraduation { get => _selectedGraduation; set => SetValue(ref _selectedGraduation, value); }


    Beimm Speichern funktioniert das ganze:

    C#-Quellcode

    1. _personModel.Graduation = SelectedGraduation;


    in der Datenbank wird dann in der Spalte GraduationId die richtige Id der Graduation eingetragen.

    Leider funktioniert das Laden der Graduation nicht:

    C#-Quellcode

    1. SelectedGraduation = _personModel.Graduation;
    da _personModel.Graduation null ist

    Auch wenn ich explizit über die Logic die Graduation suche findet er keine, da Graduation der Person immer null ist.

    C#-Quellcode

    1. SelectedGraduation = GraduationLogic.GetGraduation(_personModel.Graduation.Id);


    Ich überlege jetzt, ob ich in der Person nur den Namen der Graduierung speichere und nicht die ganze Graduierung, wobei das dann aber beim auslesen der Gürtelfarbe usw. vermutlich Probleme bringt.

    Echt kniffelig

    EDIT: ich hab das Problem gelöst, ich hatte im Provider vergessen, die Graduierungen bei der Person zu Includen:

    C#-Quellcode

    1. public Person Get(int id)
    2. {
    3. return HasEntries() ? Context.People.Where(p => p.Id == id).Include(l => l.AcessData).Include(g => g.Graduation).FirstOrDefault() : null;
    4. }

    Nun hänge ich noch an dem Problem das mir die Combobox nicht die Selektierte Graduierung anzeigt, obwohl das Property gefüllt ist und die ComboBox gebunden ist:

    XML-Quellcode

    1. <ComboBox Grid.Column="1" Grid.Row="2" ItemsSource="{Binding Graduations}"
    2. Margin="10" FontSize="{StaticResource FontSizeAverage}"
    3. SelectedItem="{Binding SelectedGraduation, Mode=TwoWay, UpdateSourceTrigger=PropertyChanged}"/>

    Misteriös

    "Hier könnte Ihre Werbung stehen..."

    Dieser Beitrag wurde bereits 2 mal editiert, zuletzt von „MichaHo“ ()

    Hallo,
    Also so ganz klappt das alles nicht :(
    Ich hab vermutlich einen riesen Denkfehler...
    ich kann bei einer bestehenden Person die Graduierung ändern, aber wenn ich eine neue Person anlege, erhalöte ich einen SQL Uniqe Fehler

    Im Grunde ist es so, jede Person hat genau 1 Graduierung. Die Graduierung kann zwar geändert werden, aber es ist immer nur 1.
    Die Gradueirungen werden mir angelegt (sind 25 Stück).

    Bei der ersten Person wird in die Person Tabelle auch die richtige Id eingetragen, aber bei einer neuen Person kanllt es dann...
    Ich komm nicht weiter in meinem Denken...
    "Hier könnte Ihre Werbung stehen..."
    So,
    nun scheint es zu funktionieren.
    Ich habe in der Person Klasse nun lediglich die ID der Graduierung drin.
    Über den Provider kann ich mir dann, wenn ich sie brauche, die dazugehörige Graduierung holen.

    Was aber absolut nicht klappen will ist, das die Combobox mir beim laden das Selected Item setzt... das Textfeld der Combobox ist immer leer, obwohl das Property SelectedGraduation gesetzt ist, definitiv.
    Lege ich eine beue Person an, dann greift Graduations.FirstOrDefault() und dann wirds angezeigt, nur beim Update der Person nicht.

    Die Propertys im Viewmodel:

    C#-Quellcode

    1. public ObservableCollection<Graduation> Graduations { get; set; }
    2. private Graduation _selectedGraduation;
    3. public Graduation SelectedGraduation { get => _selectedGraduation; set => SetValue(ref _selectedGraduation, value); }


    Die Collection wird so geladen:

    C#-Quellcode

    1. private ObservableCollection<Graduation> GetGraduations()
    2. {
    3. var graduationlist = GraduationLogic.GetGraduations();
    4. Graduations = new ObservableCollection<Graduation>();
    5. graduationlist.ForEach(g => Graduations.Add(g));
    6. return Graduations;
    7. }


    und dann setz ich die SelectedGraduation:

    C#-Quellcode

    1. SelectedGraduation = _personModel.GraduationId == 0 ? Graduations.FirstOrDefault() : GraduationLogic.GetGraduation(_personModel.GraduationId);


    und im Xaml sieht es dann so aus:

    XML-Quellcode

    1. <ComboBox Grid.Column="1" Grid.Row="2"
    2. Margin="10"
    3. ItemsSource="{Binding Graduations}"
    4. SelectedItem="{Binding SelectedGraduation, Mode=TwoWay, UpdateSourceTrigger=PropertyChanged}"
    5. FontSize="{StaticResource FontSizeAverage}"/>


    die GraduationLogic.GetGraduation(_personModel.GraduationId) gibt mir eine Graduation zurück, also genau den Typ der Selected Graduation.
    Schaue ich im Haltepunkt auf SelectedGraduation hab ich auch genau die richtige Graduation drin. nur wird diese in der Combobox nicht als SelectedItem gesetzt.
    Was läuft denn da falsch?
    "Hier könnte Ihre Werbung stehen..."
    verstehe ich das richtig - du bist von der Enumselei abgekommen - gute Sache.
    Ich sehe das relational, es gibt die Relation
    Graduierung->Person
    Also eine Graduierung wird bei vielen Personen verwendet, eine Person hat genau eine Graduierung.
    Und dann werkelst du an was ich den Joining-View nenne, nämlich via Combobox-Spalten willst du Graduirungs-Werte in der PersonTabelle anzeigen und auswählbar machen.

    Jo, die wpf-combo ist lausig, das ist ja schon in WinForms nicht ganz trivial, aber die Wpf kennt nun SelectedItem, SelectedValue, SelectedValuePath, SelectedItemPath, DisplaymemberPath, SelectedItemBinding, SelectedValueBinding, DataSource, ItemsSource, ... (ich übertreibe bischen) - jdfs ich brauchte da auch sehr lange, bis ich das iwie hingeknispelt hatte.
    Ich guckma:

    XML-Quellcode

    1. <DataGrid hlp:GridEx.Range="d" ItemsSource="{Binding cvPersonProfessions}" AutoGenerateColumns="False" IsSynchronizedWithCurrentItem="True" >
    2. <DataGrid.Columns>
    3. <DataGridComboBoxColumn
    4. Header="Person" DisplayMemberPath="Name"
    5. ItemsSource="{Binding PersonProfessionsEdm.cvPersons, Source={x:Static vm:MainViewModel.Instance}}"
    6. SelectedItemBinding="{Binding Person}" />
    7. <DataGridComboBoxColumn
    8. Header="Profession" DisplayMemberPath="Name"
    9. ItemsSource="{Binding PersonProfessionsEdm.cvProfessions, Source={x:Static vm:MainViewModel.Instance}}"
    10. SelectedItemBinding="{Binding Profession}" />
    11. </DataGrid.Columns>
    12. </DataGrid>
    Dazu das Datenmodell:
    Person->PersonProfession<-Profession

    Also eine m:n - Relation Personen und Berufe.
    Und die Zuordnungs-Entität hat die Properties Person und Profession.
    Im gezeigten DG werden die Zuordnungen angezeigt, und man kann jeder Zuordnung mittels der beiden ComboColumns eine annere Person andrehen oder eine annere Profession.
    die ItemSources binden bei mir an CollectionViews, die im Viewmodel instanziert sind.
    So kann ich im Viewmodel über CollectionView.CurrenPosition direkt abfragen, was im View angewählt ist.

    Zu die Graduationen: Ladt die dir diese Tabelle initial runter, und behalte die Auflistung davon im Speicher. Das stell ich mir super-verwirrend vor, wenn man da immer mal wieder iwas aus der DB abrufen will.
    Und der DropDown einer Combo funzt eben nur, wenn alle Daten bereitstehen.

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

    Hi @ErfinderDesRades Danke Dir, schaue ich mir morgen nochmal an.
    aber verstehe ich das jetzt richtig, die Graduation Klasse benötigt einen Verweis auf die Person und die Personklasse benötigt nix?
    die Enums brauch ich nur noch um die einzelnen Einträge zu erstellen, die sind ja fast alle Unterschiedlich sieht man oben in der Seed Methode. Die Liste aller Graduierungen lade ich nur, wenn ein neues Mitglied angelegt oder ein bestehendes geändert wird. Ich kann die Auflistung aber auch beim Starten laden und im ApplicationViewModel halten. CollectionView klappt bei mir nur im Xaml, da ich in .NetCore arbeite. Dafür hab ich ja das SelectedGraduation Property und beim erstellen eines neuen Mitglieds zeigt die Combo das auch an, nur beim Update nicht.
    Beim Neuanlegen wird SelectedGraduation mit Auflistung.FirstOrDefault gefüllt, beim Update wird aus der DB die entsprechende Graduierung geholt.
    Alle Versuche mit der Klasse Graduierung heute die ich versucht habe waren irgendwie murks. So wie ich es nun habe (siehe oben) klappt es beim Anlegen und Ändern bis auf das SelectedItem Problem
    "Hier könnte Ihre Werbung stehen..."

    MichaHo schrieb:

    aber verstehe ich das jetzt richtig, die Graduation Klasse benötigt einen Verweis auf die Person und die Personklasse benötigt nix?

    Ich nehme an, du beziehst dich auf dieses:
    Graduierung->Person
    Damit meine ich Graduierung ist die Parent-Entity, und Person die Child-Entity
    Ups- das habich ja fasch geschrieben - es ist keine m:n, sondern eine 1:n Relation.
    Bedeutet, dass 1 Graduierung mit n Personen verknüpft ist.
    Die Verknüpfung besteht wie immer im relationalen Kontext darin, dass jede Person auf genau 1 Graduierung verweist.
    Während die Graduierung sich selbst genug ist.

    MichaHo schrieb:

    CollectionView klappt bei mir nur im Xaml, da ich in .NetCore arbeite.
    Verstehe ich nicht.
    Ich hab im Viewmodel die Properties so eingerichtet und kann daran binden wie an jede annere Prop:

    C#-Quellcode

    1. public ListCollectionView cvPersons { get; private set; }
    2. public ListCollectionView cvProfessions { get; private set; }
    3. public ListCollectionView cvPersonProfessions { get; private set; }
    4. partial void OnInitialized() { if (IsInDesignMode) InitView(true); }
    5. public void InitView(bool generateData) {
    6. if (generateData) GenerateData();
    7. cvPersons = (ListCollectionView)CollectionViewSource.GetDefaultView(Persons);
    8. cvProfessions = (ListCollectionView)CollectionViewSource.GetDefaultView(Professions);
    9. cvPersonProfessions = (ListCollectionView)CollectionViewSource.GetDefaultView(PersonProfessions);
    10. }
    Persons, Professions, PersonProfessions sind ObservableCollections von VM-Klassen.
    Und sowas geht in .NetCore nicht?


    MichaHo schrieb:

    Die Liste aller Graduierungen lade ich nur, wenn ein neues Mitglied angelegt oder ein bestehendes geändert wird.
    Komisch.
    Nach meim Verständnis der Funktionsweise einer Combobox braucht man die Liste aller Graduierungen - also eben wirklich alle - in dem Moment, wo die Combobox geöffnet wird, und im DropDown eben alle Graduierungen zur Auswahl anbieten soll.
    Und das findet statt, bevor am Person-Datensatz die Graduation-Property geändert wird.
    Und das findet immer wieder statt, und bei jeder Person muss dieselbe Graduation-Liste sich im Dropdown öffnen - ist doch unsinnig, dieselbe Liste wasweisichwieoft runterzuladen - es ist ja doch immer dieselbe, und die ändert sich ja auch nicht.

    Und inne Praxis funktionieren Combobox-Columns auch im zugeklappten Zustand nicht, wenn in ihrer ItemsSource nicht alle Graduierungen drinne sind.
    Angenommen eine Tabelle von Personen, wo mw. 4 verschiedene Graduierungen auftreten.
    Dann muss die ItemsSource der ComboColumn mindestens diese 4 Graduierungen enthalten, sonst kann diese Person-Tabelle nicht ohne AnzeigeFehler angezeigt werden.

    Ach ich sollte besser Klappe halten. Ich sehe jetzt erst, dass du mit einer Combobox unterwegs bist, nicht mit einer ComboboxColumn.

    Vielleicht dieses:

    MichaHo schrieb:

    das Textfeld der Combobox ist immer leer
    Vielleicht musste DisplayMember, DisplaymemberBinding, DisplayMemberPath - was auch immer - setzen.
    Und mit ValueMember gibts auch sowas - und da kann man entweder über SelectedItem oder über SelectedValue gehen.
    Gebunden werden muss das an eine Eigenschaft der Person - nicht an irgendeine Property im Viewmodel.
    SelectedValue muss an Person.GraduationId anbinden, altenativ muss SelectedItem an Person.Graduation anbinden.
    Ich würde eher über SelectedValue versuchen, bei SelectedItem weiss ich nicht, ob EF damit klarkommt.

    Aber als ersten Schritt das DisplayMember-Problem lösen.

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

    ErfinderDesRades schrieb:

    Und sowas geht in .NetCore nicht?

    Nee, das geht nicht. Es soll gehen mit einem Nuget Paket aber das hab ich noch nicht hin bekommen.
    Zumal das nuget paket auch einen Verweis auf die WindowsBase möchte und das ist ja nicht MVVM like...


    Nu zu deinem Post oben. Dann hab ich ja doch nicht soooo viel falsch gemacht.
    Meine Person Klasse hat nun eine GraduationId die auf die entsprechende Graduation zeigt. das klappt wunderbar.

    Das Laden der Graduations verschiebe ich ins ApplicationViewModel, dann hab ich die Liste dauerhaft verfügbar und kann mir daraus dann die entsprchende Graduation raus holen.
    DisplayMember schau ich mir an und teste es aus.

    Danke Dir

    P.S. ich bin wie gesagt auf .NetCore 3.1
    "Hier könnte Ihre Werbung stehen..."

    ErfinderDesRades schrieb:

    Nach meim Verständnis der Funktionsweise einer Combobox braucht man die Liste aller Graduierungen - also eben wirklich alle - in dem Moment, wo die Combobox geöffnet wird, und im DropDown eben alle Graduierungen zur Auswahl anbieten soll.
    Und das findet statt, bevor am Person-Datensatz die Graduation-Property geändert wird.


    Und genau DAS hab ich die ganze Zeit nicht beachtet, denn ich setze das SelectedGraduationProperty beim laden der Seite und hole die entsprechende Graduation aus der DB, das klappt dann nicht, weil SelectedGraduation das nicht mitbekommt, bzw. die View....

    Also hab ich deinen Rat befolgt und die Liste der Graduierungen ins ApplicationViewModel gepackt. Das ApplicationViewModel ist statisch über IoC verfügbar und wird direkt bei Programmstart erstellt, somit ist auch dann bereits die Liste verfügbar... klappt perfekt.
    Meine Lade Methode im ViewModel PersonDetailViewModel

    C#-Quellcode

    1. private void ReloadData()
    2. {
    3. FirstName = new TextEntryViewModel { Label = "Vorname", OriginalText = $"{_personModel?.FirstName}" };
    4. LastName = new TextEntryViewModel { Label = "Nachname", OriginalText = $"{_personModel?.LastName}"};
    5. EntryDate = new DateEntryViewModel { Label = "Einstieg Datum", OriginalText = $"{_personModel?.EntryDate.ToShortDateString()}" };
    6. SelectedPersonType = _personModel.PersonType;
    7. SelectedGender = _personModel.Gender;
    8. SelectedGraduation = _personModel.GraduationId > 0 ? IoC.Application.Graduations.First(g => g.Id == _personModel.GraduationId): IoC.Application.Graduations.FirstOrDefault() ;
    9. }

    Nun wird auch die ComboBox mit der richtigen Graduierung angezeigt und die Liste enthält alle möglichen Graduierungen.
    Jetzt bastel ich noch an der ComboBox bisschen rum, das mir die Einträge gruppiert werden. Sieht schöner aus denke ich.
    Danke Dir Echkard!!
    "Hier könnte Ihre Werbung stehen..."
    nochmal Nachfrage zu post#14: Verstehe ich das richtig, dasses in .NetCore kein Äquivalent zu einer CollectionView gibt?

    In .NetOhneCore haben CollectionViews 4 Aufgaben:
    • Filtern
    • Sortieren
    • CurrentManagment
    • Gruppieren (wovon ich nicht so viel halte, und was auch sehr kompliziert wird)
    Muss man sich diese Dinge in .NetCore nun selber basteln?
    Kann ich mir kaum vorstellen, dass in .Core zB keine Sortierung vorgesehen ist, wenn der User in einem DG auf einen Spaltenkopf klickst - das findich ziemlich banale Standard-Funktionalität...
    Das würde ich mal recherchieren.
    Hallo,
    soweit ich recherchiert habe, müsste man in .Core das WindowsBase Nuget Paket im Viewmodel Projekt installieren, was aber ja die View ins ViewModel holt und daher nicht MVVM like ist.
    Gruppieren und sortieren kann man direkt im View machen, dort kann man eine CollectionViewSource erstellen und benötigt dann einen Verweis auf Componentmodel.
    Filtern hab ich in meinem Fall über den Provider gelöst in dem ich der Logic einfach die zur Filterung nötigen Infos mitgebe.

    Aber vielleicht hat @Nofear23m noch eine bessere Lösung
    "Hier könnte Ihre Werbung stehen..."
    Hallo

    @MichaHo hat recht. Man muss jetzt WindowBase nicht unbedingt per NuGet holen oder einen Verweis setzen sondern kann schlicht ComponentModel über NuGet holen.
    Das sollte im Grunde reichen. Habs aber noch nicht probiert.

    Was die verletzung des Pattern angeht muss man das genauer betrachten. Das Pattern wird ja nicht verletzt in dem Sinn das ich die View ins ViewModel hole was man damit ja nicht macht. Was hierbei nur mit der einbindung der WindowBase passiert ist, das das ViewModel in dem Moment nicht mehr Cross-Plattform fähig ist. Was im Grunde ja völlig egal ist wenn ich eine WPF Anwendung erstelle. Erstellei ich eine Xamarin Anwendung schaut die sache wieder anders aus, in diesem Fall kann ich dann einfach keine ICollectionView verwenden (was ja glaube ich unter Xamarin eh nicht geht). Will ich also Cross-Plattform fähig bleiben muss ich die funktionalität manuell machen oder ein NuGet Paket finden welches die ICollectionView enthält und Cross-Plattform fähig ist.

    Aber das Pattern verletze ich damit nicht weil ich keinen Bezug auf die View habe, denn auch wenn die WindowBase von "Windows" kommt ist das ja nicht die "View" oder ein Element (Control) aus meiner Applikation.
    Das ViewModel bleibt somit weiterhin Testbar und ist weiterhin entkoppelt vom rest der Anwendung.

    Ich hoffe ich konnte trotzdem etwas behilflich sein.

    Grüße
    Sascha
    If _work = worktype.hard Then Me.Drink(Coffee)
    Seht euch auch meine Tutorialreihe <WPF Lernen/> an oder abonniert meinen YouTube Kanal.

    ## Bitte markiere einen Thread als "Erledigt" wenn deine Frage beantwortet wurde. ##