CreateInstance, Verhindern des Aufrufs von Konstruktoren abgeleiteter Klassen

  • C#
  • .NET (FX) 4.5–4.8

Es gibt 20 Antworten in diesem Thema. Der letzte Beitrag () ist von RodFromGermany.

    CreateInstance, Verhindern des Aufrufs von Konstruktoren abgeleiteter Klassen

    Moin Leute,
    ich habe in 3 abgeleiteten Klassen verschiedene Algorithmen gekapselt, die ich in mehreren Instanzen einsetzen möchte.
    Um sicherzustellen, dass alle diese Instanzen von genau einer Klasse erstellt werden, möchte ich die Konstruktoren dieser Klassen protected machen und die Instanziierung in einer CreateInstance()-Prozedur vornehmen:
    Spoiler anzeigen

    C#-Quellcode

    1. public class BASE_CLASS
    2. {
    3. protected BASE_CLASS() { }
    5. public static BASE_CLASS CreateInstance()
    6. {
    7. // TODO: Festlegen, welcher Algorithmusverwendet wird
    8. return new CLASS_1(); // hier kommt der Fehler
    9. //return new CLASS_2();
    10. //return new CLASS_3();
    11. }
    12. }
    14. public class CLASS_1 : BASE_CLASS
    15. {
    16. protected CLASS_1() { }
    17. }
    19. public class BASE_CLASS_2 : BASE_CLASS
    20. {
    21. protected BASE_CLASS_2() { }
    22. }
    24. public class CLASS_2 : BASE_CLASS_2
    25. {
    26. protected CLASS_2() { }
    27. }
    29. public class CLASS_3 : BASE_CLASS_2
    30. {
    31. protected CLASS_3() { }
    32. }
    Allerdings kommt in CreateInstance() der Fehler
    'CLASS_1.CLASS_1()' is inaccessible due to its protection level
    Sind die Konstruktoren public, funktioniert das.
    Weiß jemand, wie ich das gestalten muss, damit das so funktioniert, wie es der Plan ist?
    Falls Du diesen Code kopierst, achte auf die C&P-Bremse.
    Jede einzelne Zeile Deines Programms, die Du nicht explizit getestet hast, ist falsch :!:
    Ein guter .NET-Snippetkonverter (der ist verfügbar).
    Programmierfragen über PN / Konversation werden ignoriert!

    VB1963 schrieb:

    ist der Fehler weg
    aber ich kann die Konstruktoren immer noch von außen aufrufen:

    C#-Quellcode

    1. class abc
    2. {
    3. BASE_CLASS instance;
    4. public abc()
    5. {
    6. instance = BASE_CLASS.CreateInstance(); // soll gehen
    7. instance = new CLASS_1(); // soll nicht gehen
    8. }
    9. }
    Falls Du diesen Code kopierst, achte auf die C&P-Bremse.
    Jede einzelne Zeile Deines Programms, die Du nicht explizit getestet hast, ist falsch :!:
    Ein guter .NET-Snippetkonverter (der ist verfügbar).
    Programmierfragen über PN / Konversation werden ignoriert!

    Spoiler anzeigen

    VB.NET-Quellcode

    1. Class abc
    2. Private instance As BASE_CLASS
    3. Public Sub New()
    4. instance = BASE_CLASS.CreateInstance() ' soll gehen
    5. instance = New CLASS_1() ' soll nicht gehen
    6. End Sub
    7. End Class
    9. Public Class BASE_CLASS
    10. Protected Sub New()
    11. End Sub
    13. Public Shared Function CreateInstance() As BASE_CLASS
    14. ' TODO: Festlegen, welcher Algorithmusverwendet wird
    15. Return New CLASS_1() ' hier kommt der Fehler
    16. 'return new CLASS_2();
    17. 'return new CLASS_3();
    18. End Function
    20. Private Class CLASS_1
    21. Inherits BASE_CLASS
    22. Friend Sub New()
    23. End Sub
    24. End Class
    25. Private Class BASE_CLASS_2
    26. Inherits BASE_CLASS
    27. Friend Sub New()
    28. End Sub
    29. End Class
    30. Private Class CLASS_2
    31. Inherits BASE_CLASS_2
    32. Friend Sub New()
    33. End Sub
    34. End Class
    35. Private Class CLASS_3
    36. Inherits BASE_CLASS_2
    37. Friend Sub New()
    38. End Sub
    39. End Class
    40. End Class

    ...ob's so noch sinnvoll ist - kann ich jetzt nicht beurteilen...

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

    VB1963 schrieb:

    beurteilen
    Ja, das funktioniert, aber das Design mit internen Klassen widerstrebt mir ...
    Falls Du diesen Code kopierst, achte auf die C&P-Bremse.
    Jede einzelne Zeile Deines Programms, die Du nicht explizit getestet hast, ist falsch :!:
    Ein guter .NET-Snippetkonverter (der ist verfügbar).
    Programmierfragen über PN / Konversation werden ignoriert!

    Ich hätte eine abstrakte oder überschreibbare CreateInstance-Methode in die Basisklasse gemacht und anschließend in den speziellen Klassen überschrieben und dort den eigenen Konstruktor aufgerufen.
    So kannst du den Konstruktor theoretisch sogar private machen. :)
    lg.

    LucaWelker

    LucaWelker schrieb:

    in den speziellen Klassen überschrieben
    Jou, das war die richtige Herangehensweise.
    Spoiler anzeigen

    C#-Quellcode

    1. class abc
    2. {
    3. BASE_CLASS instance;
    4. public abc()
    5. {
    6. instance = BASE_CLASS.CreateInstance(); // soll gehen
    7. //instance = new CLASS_1(); // soll nicht gehen
    8. }
    9. }
    11. public class BASE_CLASS
    12. {
    13. protected BASE_CLASS() { }
    15. public static BASE_CLASS CreateInstance()
    16. {
    17. // TODO: Festlegen, welcher Algorithmus verwendet wird
    18. return CLASS_1.CreateClass();
    19. //return CLASS_2.CreateClass();
    20. //return CLASS_3.CreateClass();
    21. }
    22. }
    24. public class CLASS_1 : BASE_CLASS
    25. {
    26. protected internal static BASE_CLASS CreateClass() { return new CLASS_1(); }
    27. protected CLASS_1() { }
    28. }
    30. public class BASE_CLASS_2 : BASE_CLASS
    31. {
    32. protected BASE_CLASS_2() { }
    33. }
    35. public class CLASS_2 : BASE_CLASS_2
    36. {
    37. protected internal static BASE_CLASS CreateClass() { return new CLASS_2(); }
    38. protected CLASS_2() { }
    39. }
    41. public class CLASS_3 : BASE_CLASS_2
    42. {
    43. protected internal static BASE_CLASS CreateClass() { return new CLASS_3(); }
    44. protected CLASS_3() { }
    45. }
    Falls Du diesen Code kopierst, achte auf die C&P-Bremse.
    Jede einzelne Zeile Deines Programms, die Du nicht explizit getestet hast, ist falsch :!:
    Ein guter .NET-Snippetkonverter (der ist verfügbar).
    Programmierfragen über PN / Konversation werden ignoriert!

    RodFromGermany schrieb:

    Konstruktoren dieser Klassen protected machen


    Machs lieber private und implementier ein Singelton-Pattern. Dürfte das sein, was du suchst
    In general (across programming languages), a pointer is a number that represents a physical location in memory. A nullpointer is (almost always) one that points to 0, and is widely recognized as "not pointing to anything". Since systems have different amounts of supported memory, it doesn't always take the same number of bytes to hold that number, so we call a "native size integer" one that can hold a pointer on any particular system. - Sam Harwell

    Radinator schrieb:

    Dürfte das sein, was du suchst
    Nein.

    RodFromGermany schrieb:

    die ich in mehreren Instanzen einsetzen möchte.
    Private geht nicht, da meckert der Compiler.
    Falls Du diesen Code kopierst, achte auf die C&P-Bremse.
    Jede einzelne Zeile Deines Programms, die Du nicht explizit getestet hast, ist falsch :!:
    Ein guter .NET-Snippetkonverter (der ist verfügbar).
    Programmierfragen über PN / Konversation werden ignoriert!

    Hi
    hätte das entweder über nested types oder über Friend gelöst. Wenn Erben zulässig sein sollen, kann man auch eine statische, interne Methode CreateInstance pro Typ definieren, die den parameterlosen Konstruktor aufruft.
    Nested types sind ok, wenn sie ausschließlich im Typ selbst verwendet werden.
    Ziel von Friend ist es, den Zugriff innerhalb einer Assembly zu behalten. D.h. Verletzungen von außerhalb der in sich geschlossenen Komponente sind generell unterbunden, innerhalb der Assembly aber nicht, da ist der Programmierer dafür zuständig, dass keine ungültigen Aufrufe geschehen. I.A. werden Friend, etc. nur innerhalb eines "Moduls" (nicht mit dem VB-Module oder Assemblymodulen verwechseln, ich meine damit eine komplette Komponente) verwendet, d.h. von außerhalb dürfen keine Aufrufe kommen.

    Viele Grüße
    ~blaze~

    Vielleicht wäre die Nutzung von Reflection auch eine Möglichkeit?
    Spoiler anzeigen

    C#-Quellcode

    1. using System.Reflection;
    3. namespace ConsoleApplication1
    4. {
    5. class Program
    6. {
    7. static void Main(string[] args)
    8. {
    9. var a = Derived.CreateInstance();
    10. a.SaySomething();
    11. Console.ReadLine();
    12. }
    13. }
    14. }
    16. public class BaseClass
    17. {
    18. protected BaseClass()
    19. {
    20. }
    22. public static Derived CreateInstance()
    23. {
    24. return Activator.CreateInstance<Derived>();
    25. }
    27. }
    29. public class Derived : BaseClass
    30. {
    31. public void SaySomething()
    32. {
    33. Console.WriteLine("You have been terminated.");
    34. }
    35. }

    Higlav schrieb:

    Reflection
    ist da doch etwas übertrieben.
    Falls Du diesen Code kopierst, achte auf die C&P-Bremse.
    Jede einzelne Zeile Deines Programms, die Du nicht explizit getestet hast, ist falsch :!:
    Ein guter .NET-Snippetkonverter (der ist verfügbar).
    Programmierfragen über PN / Konversation werden ignoriert!

    hmm - hab ich jetzt das Problem nicht kapiert, oder warum kommt mir das so einfach vor?

    VB.NET-Quellcode

    1. Public Class Foo
    2. Protected Sub New()
    3. End Sub
    5. Public Shared Function Create(i As Integer) As Foo
    6. If i = 1 Then Return New Foo_1
    7. If i = 2 Then Return New Foo_2
    8. Throw New ArgumentException
    9. End Function
    10. End Class
    12. Public Class Foo_1 : Inherits Foo
    13. End Class
    15. Public Class Foo_2 : Inherits Foo
    16. End Class
    Nach dem Muster sind übrigens zB die Klassen WebRequest, HttpWebRequest, FtpWebRequest architektet.

    ah - aber wie wäre es mit dem hier?

    VB.NET-Quellcode

    1. Public MustInherit Class Foo
    2. Protected Sub InitClass(item As Foo)
    4. End Sub
    5. End Class
    7. Public Class Foo_1 : Inherits Foo
    8. Public Sub New()
    9. InitClass(Me)
    10. End Sub
    11. End Class
    13. Public Class Foo_2 : Inherits Foo
    14. Public Sub New()
    15. InitClass(Me)
    16. End Sub
    17. End Class

    Da kann zwar jeder ein Foo_1, Foo_2 erzeugen, aber der Init-Sub der Basisklasse ist unumgänglich.

    ErfinderDesRades schrieb:

    Da kann zwar jeder ein Foo_1, Foo_2 erzeugen, aber
    das ist eine andere Geschichte, denn der ursprüngliche Plan war, dass an einer Stelle festgelegt sein soll, dass ausschließlich Foo_1, nicht aber Foo_2 bzw. umgekehrt erzeugt werden kann.
    Falls Du diesen Code kopierst, achte auf die C&P-Bremse.
    Jede einzelne Zeile Deines Programms, die Du nicht explizit getestet hast, ist falsch :!:
    Ein guter .NET-Snippetkonverter (der ist verfügbar).
    Programmierfragen über PN / Konversation werden ignoriert!

    Mal nebenbei bemerkt:
    Die (eine mögliche) Lösung steht bereits in Post #7.
    Falls Du diesen Code kopierst, achte auf die C&P-Bremse.
    Jede einzelne Zeile Deines Programms, die Du nicht explizit getestet hast, ist falsch :!:
    Ein guter .NET-Snippetkonverter (der ist verfügbar).
    Programmierfragen über PN / Konversation werden ignoriert!

Facebook
Telefonspende