Willkommen auf myCSharp.de! Anmelden | kostenlos registrieren
 | Suche | FAQ

Hauptmenü
myCSharp.de
» Startseite
» Forum
» Suche
» Regeln
» Wie poste ich richtig?

Mitglieder
» Liste / Suche
» Wer ist online?

Ressourcen
» FAQ
» Artikel
» C#-Snippets
» Jobbörse
» Microsoft Docs

Team
» Kontakt
» Cookies
» Spenden
» Datenschutz
» Impressum

  • »
  • Portal
  • |
  • Mitglieder
Beiträge von IamTheBug
Thema: Static variable -> GoodPractice/BadPractice in meinem Fall?
Am im Forum: Grundlagen von C#

Danke für die Anregungen bisher.

Das mit der Facade ist mein aktueller Ansatz. Das ist auch so umgesetzt. Allerdings bin ich "genervt" von dem Injecten in jeder Klasse und wollte davon weg. Denn eigentlich greifen ja wirklich alle Klassen auf den selber Manager zu der vom Hauptprogramm bereit gestellt wird.
Im Moment mit der Facade klappt alles.
Ich wollte eben nur wissen ob es ein schlechter Ansatz ist auf diese Static Getter umzusatteln.

Thema: Static variable -> GoodPractice/BadPractice in meinem Fall?
Am im Forum: Grundlagen von C#

Das wäre eine Idee aber dann "verbaue" ich mir das Vererben. Ich kann dann ja von keiner anderen Klasse mehr erben, falls dies mal notwendig sein sollte.

Ausserdem muss ich den Manager ja trotzdem mit übergeben:



    public abstract class MyBaseClass
    {
        public MyBaseClass(IDrawManager drawManager)
        {
            DrawManager = drawManager;
        }
        protected IDrawManager DrawManager { get; }
    }

    public class MyOtherClass : MyBaseClass
    {

        public MyOtherClass(IDrawManager drawManager) : base(drawManager)
        {

        public void DrawSomeThing()
        {
            DrawManager.DrawLine();
        }
    }

Diese Übergabe die im Construktor von MyOtherClass geschieht, die wollte ich eigentlich los werden.

Thema: Static variable -> GoodPractice/BadPractice in meinem Fall?
Am im Forum: Grundlagen von C#

Hallo,

meine Situation ist folgende:

Ich schreibe ein kleines Plugin für ein Programm. Die Spezifikation sieht vor das meine Plugin-dll eine Klasse enthalten muss die von der abstrakten Klasse "CustomPlugin" ableitet.
CustomPlugin wird dabei von dem Hauptprogramm bereit gestellt.
Das Hauptprogramm sucht in der dll nach der Klasse und lädt diese. Es gibt diverse Funktionen funktionen die die abstrakte Klasse bereit stellt und die ich dann überschreiben kann oder implementieren muss.

Weiterhin stellt das Hauptprogramm über die abstrakte Klasse Eigenschaften bereit. Diese Eigenschaften verweisen auf sogenannte "Manager". Mit der Verwendung der Manager z.B. DrawManager kann mein plugin das Hauptprogramm veranlassen etwas in sein Fenster zu zeichnen.

Soweit so gut.
Jetzt besteht mein Plugin aber nicht nur aus einer Klasse in einer Datei sondern aus mehreren.
Jetzt bin ich jedesmal dabei in jeder Klasse per Dependency Injection im Konstruktor diesen Manager und andere zu übergeben. Das ganze ist natürlich sehr nervig.

Meine Frage:
Kann ich nicht einfach eine statische Eigenschaft des Managers in meiner Hauptklasse erstellen und alle anderen Klassen greifen dann einfach darauf zu? Ist das schlechter Programmierstiel?

Rahmenbedingung sind auch das dieses statische Plugin nur einen Getter hat und nicht verändert werden kann.
Die Manager verändern sich durch das Hauptprogramm auch nicht, sie bleiben die ganze Zeit die selben nach dem initialisieren.
In Hinsicht auf TestBarkeit könnte ich meinen Klassen zusätzlich noch öffentliche Eigenschaften spendieren um den Manager der einzelnen Klassen expliziet zu setzen, so das diese Klasse nicht auf die statische Eigenschaft der Hauptklasse zurück greift.

GoodPractice/BadPractice? Gibt es andere Vorschläge?

Kurzes Beispiel wie ich es mir vorstellen anstatt in "MyOtherClass" im Constructor alle Manager zu übergeben.



    public class MyPlugin : CustomPlugin
    {
        public static IDrawManager StaticDrawManager { get; private set; }

        //wird vom Hauptprogramm durch CustomPlugin bereitgestellt
        protected IDrawManager DrawManager { get; }

        public override void Initialize()
        {
            //Methode wird vom Hauptprogram gerufen, initialisiere etwas

            StaticDrawManager = DrawManager;
        }
    }

    public class MyOtherClass
    {

        public MyOtherClass()
        {
            //beim initialisieren hole statischen Manager
            DrawManager = MyPlugin.StaticDrawManager;
        }

        //kann aber für UnitTests oder andere Dinge von aussen überschrieben, "umgebogen" werden
        public IDrawManager DrawManager { get; set; }

        public void DrawSomeThing()
        {
            DrawManager.DrawLine();
        }
    }

Thema: CustomMarkupExtension im XAML konfigurieren
Am im Forum: GUI: WPF und XAML

Danke Bhaal.
Auf diese Bibliothek bezog ich mich auch als ich meinte ich habe das schon einmal gesehen.
Ich wusste aber nicht genau wie es umzusetzen ist.
Das Schlüsselwort zum Erfolg heisst hier also DependencyProperty? Das wollte ich nur wissen wonach ich in dem Quelltext suchen muss. Dann schaue ich mir den Quelltext einmal genauer an.

Thema: CustomMarkupExtension im XAML konfigurieren
Am im Forum: GUI: WPF und XAML

Es geht nicht um das "Bilderding". Das war nur ein Beispiel.
Es geht mir expliziet um die oben genannte Frage. Ich würde das gerne auch auf andere MarkupExtensions anwenden die andere Funktonalität besitzen.

Thema: CustomMarkupExtension im XAML konfigurieren
Am im Forum: GUI: WPF und XAML

Hi,

ich habe für diverse Zwecke eine eigene MarkupExtension erstellt und verwende diese im XAML Code.
Das funktioniert sehr gut. Ich habe z.B. eine MarkupExtension um Bilder nachzuladen und auf Buttons zu legen oder auch zur Lokalisation.
Allerdings steckt in all diesen MarkupExtensions immer eine winzige Funktionalität die sich auf das aktuelle Projekt bezieht. Somit lässt sich das ganze nicht in eine Bibliothek auslagern und universell nutzen.

Ich habe aber schon oft bei anderen Bibliotheken/Projekten gesehen das die MarkupExtension bevor sie benutzt wird im XAML Code configuriert wird.
Zum Beispiel so:


<window 
    x:Class="Klasse"
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
    xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
    xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
    
    xmlns:local="clr-namespace:local"
    xmlns:images="clr-namespace:local.Images"
    
    MinWidth="300" MinHeight="300" 
    images:ImageFolder="resourcen\images"

    mc:Ignorable="d">

   
    <Grid>
        <ToolBarControl>
            <BarButtonItem Content="test"
                               Glyph="{images:Image cmdSave, Size=Size16}" 
                               LargeGlyph="{images:Image cmdSave}"/>
       </ToolbarControl>
    </Grid>

Wie man sieht wird bei dem BarButton das Glyph über die Image MarkupExtension gesetzt.
Und weiter oben (das ist was ich erreichen möchte) wird das ganze konfiguriert und gesagt wo die Bilder liegt:

images:ImageFolder="resourcen\images"

Wie wird sowas umgesetzt?
Wie gesagt bei anderen Projekten habe ich das schon gesehen das es möglich ist. Aber ich weiss nicht wie man es umsetzen kann.

Viele Grüße

Thema: Sind diese Bücher geeignet?
Am im Forum: Buchempfehlungen

Hi,

also ich hatte das Buch einmal auf deutsch gelesen:
C# 6 mit Visual Studio 2015: Das umfassende Handbuch: Spracheinführung, Objektorientierung, Programmiertechniken

Es ist meiner Meinung nach sehr gut. Fängt aber auch komplett von vorne an und geht dann aber auch noch über das reine c# hinaus indem es auch Dinge wie WPF behandelt.

Es gibt noch ein ähnlich Buch des Verlages:
Professionell entwickeln mit C# 6 und Visual Studio 2015: Das Praxisbuch. Alle Phasen in der Praxis: vom Entwurf bis zum Deployment.

Dies wird wohl dem Titel nach nicht ganz so auf C# Grundlagen eingehen.


Du kannst dir auch kostenlosden Vorgänger angucken und lesen:http://openbook.rheinwerk-verlag.de/visual_csharp_2012/

Zu dem anderen Buch kann ich nichts beitragen.

Thema: [abstract class] Validation auch in abgeleiteten Klassen
Am im Forum: Grundlagen von C#

Hi,

ich habe mich mal daran gemacht und die ersten Schritte unternommen.
Ich habe noch eine Frage, eventuell hast du einen einen Tipp.

Ich wollte in meinem Programm eine Art Fenster "Fehlerliste" erstellen. Ähndlich der Fehlerliste im Visual Studio.
Dort sollen immer alle Fehler aller Objekt sofort aufgesammelt und angezeigt werden.
Jetzt stellt sich mir die Frage, wenn ich z.B. IValidatableObject ode etwas ähnliches eigenes Implementiere, wie bekommt die GUI (WPF) mit das sich der validierte Zustand eventuell geändert hat.
Sollte ich an der Stelle selber ein event einführen, welches darüber benachrichtigt?

Wie macht das IDataErrorInfo? Wann ruft dieses die Fehlermeldungen wieder ab und aktualisiert sich. Ist das an INotifyPropertyChanged gekoppelt?

Thema: [abstract class] Validation auch in abgeleiteten Klassen
Am im Forum: Grundlagen von C#

Hm, ok.

Dann werde ich diesen Weg einschlagen und versuchen umzusetzen.

Ich habe noch eine Frage zu deinem Beispiel.
Leitet IValidatableEntity von IValidatable ab.
Was ist der Unterschied zwischen IValidatable und IValidatableObject. Das habe ich auch noch gefunden.

Wo kommt die IsValid Methode her? Auch aus einem Standard-Interface oder wurde es von dir "eingeführt"?

Danke und viele Grüße

Thema: [abstract class] Validation auch in abgeleiteten Klassen
Am im Forum: Grundlagen von C#

Ich denke das mit den DataAnnotations ist ein sehr guter Hinweis.
Das hatte ich so nicht auf dem Schirm.
Ich habe dazu auch ein passendes Video gefunden, das eigentlich das abfackelt was ich vorhabe.
Danke für den Tip.

Hier das Video:
C# DataAnnotations explained

Allerdings stört mich noch eine Sache daran. Jemand der die Core komponente verwendet muss selber von Hand die Überprüfung durchführen. Sprich es ist trotzdem möglich einen Namen der nicht mit "A" beginnt zu vergeben oder? Sprich man muss den Namen vergeben und anschließend immer prüfen ob dies mgl. ist oder?

Wie bekommt man eigentlich mit, welche Merkmale durch DataAnnotations eingeschränkt wurden, wenn man die Quelldaten nicht hat?

Thema: [abstract class] Validation auch in abgeleiteten Klassen
Am im Forum: Grundlagen von C#

Hallo,

danke für die bisherigen Antworten.

Eventuell sollte ich nochmal genauer erkläre was ich mir vorgestellt habe.


Ich wollte ein Programm schreiben mit dem (ich halte es jetzt mal sehr abstrakt) Objekte erstellt werden können. Diese besitzen immer einen Namen und jetzt eben noch verschiedene Eigenschaften.

Dabei gibt es bestimmte vorgaben für die Objekte. z.B. muss ein Name immer mit einem "A" anfangen.
Jetzt wollte ich eine Core dll schreiben in dem die Funktionalität der Ojekte untereinander abgebildet werd. Dort wollte ich dann z.B. im Setter des Namens eine Exception werfen.


Jetzt sieht man natürlich noch nichts.
Es soll zwei Varianten des Programms geben mit verschiedenen Oberflächen usw. Aber die Regeln in der Core Komponente bleiben ja gleich.
Deshalb hätte ich dann in XAML z.B. eine Oberfläche programmiert und ein Viewmodel dazu. So geschichten wie IDataErrorInfo oder andere Validierungswäre hätte ich dann im XAML/ViewModel abgefackelt.
Somit soll an dieser Stelle eben der Fehler abgefangen werden.

Aber jeder der die Core Komponente erhält und seine eigene Oberfläche drumherum schustert soll immer eine Exception um die Ohren geflogen bekommen sobald ein Name nicht mit einem "A" anfängt.
Denn jeman der die Core Komponente nicht direkt kennt und die Doku nur halbherzig gelesen hat soll die Konsequenzen sofort spüren :D

Thema: [abstract class] Validation auch in abgeleiteten Klassen
Am im Forum: Grundlagen von C#

Ich möchte es aber nicht als sealed haben.
Was ist, wenn eine Subklasse das Property überschreibt? Einfach, weile es noch eine weitere Überprüfung hinzufügt. Oder einfach nur, weil es im Setter noch etwas anderes machen möchte?

Zitat von p!lle
Alternativ einfach das Schlüsselwort virtual weglassen.

Falls es notwendig ist, die Property Name zu überschreiben, ist die Prüfung nur sichergestellt, wenn base.Name aufgerufen wird.

Ok. Also entweder den anderen meine Implementierung aufzwingen oder damit leben, wenn sie es überschreiben selber noch base aufzurufen?

Thema: [abstract class] Validation auch in abgeleiteten Klassen
Am im Forum: Grundlagen von C#

Hallo,

ich stehe im Moment ein wenig auf dem Schlauch. Ich denke das Problem ist eigentlich sehr gering ich weiß nur momentat nicht wie ich es angehen soll.

Ich habe eine abstrakte Klasse.


 public abstract class ObjectWithName
        {
            public virtuall string Name
            {
                get;
                set
                {
                    if (value == "Max Mustermann") throw new Exception();
                }
            }

Jetzt gibt es Klassen die davon ableiten:

z.b.
public class Person : ObjectWithName
public class Car : ObjectWithName

Das Ziel ist das alle Klassen die davon ableiten, nie den Namen "Max Mustermann" erhalten dürfen.
Ist das vorgehen so korrekt?
Was passiert, wenn eine Subklasse aber das property Name überschreibt? Dann hebelt er doch diese Validierung aus oder? Wie kann ich es umsetzen das auch in den Subklassen diese Validierung durch die Basisklasse erzwungen wird.

Viele Grüße

Thema: MVVM: darf Model andere ViewModels kennen?
Am im Forum: GUI: WPF und XAML

Zitat von ErfinderDesRades
Wenn es angezeigt werden soll, muss es ins Viewmodel.
Und ein User wird wohl angezeigt bekommen müssen, wenn eine seiner Aktionen scheitert.
Eine Möglichkeit wäre, eine Exception zu werfen. Auf jeden Fall muss das Viewmodel sich ebenfalls mit Fehleingaben auseinandersetzen - so oder so.

Das mache ich auch, ich werfe eine Exception. Egal wer auch jemals diese Klassen bzw das Model verwendet, er darf bestimmte Werte in bestimmten Kombinationen nicht belegen, deshalb wird das im Model schon abgeprüft und Exception geworfen. Und natürlich gut dokumentiert ;)
Zitat von ErfinderDesRades
Das mit den Listen ist der ganz leidige Punkt an MVVM: Nimmt man die 3-Teilung "M V VM" ernst, so folgt daraus zwangsläufig, dass sowohl in PersonViewmodel eine Liste von HouseViewmodels gehalten werden muss, als auch in PersonModel eine Liste von HouseModels.
Und es ist ein lausiges Problem, diese doppelte Listenführung konsistent zu halten.

Also ist sozusagen ein "richtiger" aber umständlicher Weg das ich die original Liste der Modelle immer "umpacke" in eine Liste von ViewModellen? Klingt bisschen umständlich für im Endeffekt wenig Ergebnis, wenn das ViewModel z.B. die Daten des Models kaum bis gar nicht verändert und nur durchreicht.

Und mir ging es auch schon wie dir. Bei meinem ersten kleineren Projekt zum testen ist mein Model/Viewmodel auch verschwommen. Mein Model war hinterher so "dumm" (hatte nur string name und int age) und das Viewmodel hatte das einfach weiter durchgereicht. Da habe ich dann auch auf eine Zwischenschicht verzichtet. Es hat alles nur unnötig aufgebläht und war bei meinem kleinen Beispiel ohne Sinn.

Thema: MVVM: darf Model andere ViewModels kennen?
Am im Forum: GUI: WPF und XAML

Vielen Dank für die Informationen und die Schilderung deines Herangehens.

Bis zu deiner Antwort auf Frage 3 konnte ich dem auch gut folgen. :) Teilweise war es so wie ich es selber schon mache und ach verstanden habe. Die Sache mit dem Business-Layer ist ein guter Hinweis, da denke ich nochmal tiefer drüber nach :).

Allerdings habe ich die Antwort auf Frage 3 nicht so ganz verstanden.

Für mich ist ja die Frage ob ich in Person


private List<House> Houses {get;set;} = new List<House>();
durch


private List<HouseViewModel> Houses {get;set;} = new List<HouseViewModel>();
ersetzen soll

Eventuell könntest du zu deiner Lösung noch etwas sagen damit ich es besser verstehe.
Vielen Dank :)

Thema: MVVM: darf Model andere ViewModels kennen?
Am im Forum: GUI: WPF und XAML

Hi,

ich habe natürlich schon viel über MVVM gelesen aber einige Sachen sind mir trotzdem noch unklar. Deshalb wollte ich mal hier nachfragen.
Ich habe folgendes (fiktives) Programm:

Model (kein 100% funktionierender Code):


public class House
{
    public string Name {get;set;}
    public Color Color {get;set;}
}

public class Person
{
    public string Name {get;set;}
    public int Age {get;set;}
    public Color FavColor {get;set { ChangeColorOfallHouses();}

    private List<House> Houses {get;set;} = new List<House>();

    public void AddHouse(House house)
   {
      if (Age < 18)
         throw new Exception("Man muss ueber 18 fuer ein Haus sein.")
      Houses.Add(house);
   }
   
   private void ChangeColorOfAllHouses() { .....}
}


Das wären meine zwei Model. Relativ einfach und simpel. Es sollte klar sein was gemeint ist.
Frage 1: Ist es richtig das schon Logik in den Models abgearbeitet wird? Also z.B. Das beim hinzufügen eines Haus schon geprüft wird ob die Person über 18 ist? Sowas muss doch nicht ins ViewModel oder?

Frage 2: Wenn beim Setzen der FavColor einer Person alle Farben der Häuser die er besitzt geändert werden soll (Häuser werden in Lieblingsfarbe gestrichen) kann doch so ein Funktionsaufruf auch im Model bleiben und muss nicht im ViewModel als Logik abgehandelt werden.

Die oben aufgeführten Punkte sind auch keine " das ist in dem Programm so Regel" sondern eine Regel die immer allgemeingültig ist. Wie gesagt das oben ist nur ein an den Haaren herbeigezogenes Beispiel.

Der Stand bis hier hin ist ja das die Models komplett alleine funktionieren und ihre unumstösslichen Regeln auch selber abarbeiten und eventuell Eigenschaften auch auf andere Objekte weiterreichen.

Jetzt habe ich ein View in XAML und ein ViewModel zu dem View erstellt in dem die Commands enthalten sind.
Weiterhin erstelle ich ein ViewModel für die Personklasse zum aufarbeiten der Daten für das View.

Frage 3: jetzt ist ja in der Personenklasse schon direkt eine Liste des HouseModels vorhanden.
Wie bekomme ich aber die darin gespeicherten Häuser in ein HouseViewModel damit diese auch für den View aufgearbetiet werden.
Soll die Personenklasse keine Liste von House sondern von HouseViewModel halten?

Thema: Struct binden und Änderungen erhalten
Am im Forum: GUI: WPF und XAML

Zitat von FZelle
Man kann nicht an structs binden, da das Valuetypes sind.

Das ist genau das was ich meine. Was mir auch klar ist. Ich wollte nur wissen ob es dafür eine Lösung gibt oder ich ebene wirklich eine Klasse selber erzeugen muss.
Dran binden kann man schon. Allerdings landen die Änderungen sonstwo in der Kopie die eben im Speicher angelegt wird.
Aber ich denke mal ich muss da selber etwas kleines schustern.

edit:
ich habe es jetzt so hingenommen und einfach eine eigene Klasse erstellt

Thema: Struct binden und Änderungen erhalten
Am im Forum: GUI: WPF und XAML

Hallo,

meine Frage bezieht sich eigentlich Grundsätzlich darauf wie ich eine Struct binden kann und die Änderungen die im Interface an der Struct vorgenommen werde mitbekomme.

Es ist folgende Situation.
Ich habe eine Klasse. Diese Klasse soll Breite und Tiefe erhalten.
Anschließend soll dieses an Textfelder gebunden werden. Eins für die Breite und eins für die Tiefe.
Ich dachte mir das es ja sicher schon Klassen von MS gibt die eine Tiefe und Breite speichern.
Also kurz nachgeschaut und es gibt die Size-Structhttps://msdn.microsoft.com/de-de/library/system.drawing.size%28v=vs.110%29.aspx

und Size3d Struct:https://msdn.microsoft.com/en-us/library/system.windows.media.media3d.size3d.aspx

Jetzt wollte ich diese in meiner Klasse verwenden um Breite und Tiefe abzubilden.
Leider funktioniert das binden dann nicht mehr so gut da die Struct ja by value gebunden wird, sprich vorher eine Kopie gemacht wird und diese verändert wird. Somit bekomme ich die Änderungen ja nicht mit.

Wie geht man mit dem "Problem" um? Muss ich jetzt wirklich selber eine Klasse schreiben mit Breite und Tiefe die im Grunde nichts anderes macht als die schon existierende Struct nur um es richtig binden zu können?


Danke und Grüße

Thema: DependencyProperty in eigener Klasse implementieren und vererben
Am im Forum: GUI: WPF und XAML

Eventuell habe ich mich falsch ausgedrückt, natürlich meine ich nicht Vererben im Sinne von Klassen vererben.
Aber im Zusammenhang von WPF spricht man doch von Vererbung oder durchreichen von Eigenschaften unterhalb des LogicTrees.
Sowas wollte ich.

In ein Regal kann ich doch Sachen reinlegen. Zum Beispiel Bücher, Schuhe usw.
Ich wollte einfach an dem Schrank ein Merkmal haben das ich zum Beispiel auf Bücher setze und anschließend haben alle Kindelemente davon zugriff drauf und wissen das sie Bücher lagern. Anschließend soll man das an einer Ebene überschreiben können und sagen können: du lagerst keine Bücher, du lagerst CDs.

So wie es eben auch bei WPF mit DependencyProperty gemacht wird. Diese werden im LogicalTree auch "durch gereicht". Setze ich zum Beispiel den Datacontext einen Usercontrols haben alle Elemente im LogicalTree drunter auch zugriff dadrauf ausser man überschreibt es und weisst ein anderen Datacontext zu.

Ich dachte ich kann DependencyProperties dafür nutzen, anstatt ein Merkmal an das Regal zu heften und anschließend sobald sich dieses ändert das den Ebene immer mitzuteilen.

Thema: DependencyProperty in eigener Klasse implementieren und vererben
Am im Forum: GUI: WPF und XAML

Hi,

ich habe eine Frage zu DependencyProperties.
Ich möchte folgendes erreichen:

Ich habe eine Klasse und diese Klasse besitzt eine Liste von Elementen einer anderen Klasse.
An einem Beispiel erklärt:


public class Level 
{}

und


public class Shelf
{
public List<Level> Levels { get; set; }
}

Es ist also so das es eine Schrankklasse gibt und diese hält eine Liste von Ebenen im Schrank.
Jetzt wollte ich an der Schrankklasse ein DependencyProperty erstellen. Das Merkmal soll den "Inhalt" angeben. Also was in dem Schrank liegt. Zum Beispiel Schuhe.
Das soll am Schrank angegeben werden und sich auf die Levelklasse durch Vererbung übertragen. So wie es im XAML ja mit styles usw gemacht wird. D.h. in den Klassen "Level" möchte ich auch darauf einfach so zugreifen können.

Das ganze sind aber Elemente die grafisch natürlich jetzt nicht dargestellt werden wie ein Button.
Geht das überhaupt so?
Ist das so angedacht oder Blödsinn?
Was benötige ich dazu?
Ein DependencyProperty?
Meine Klasse Shelf muss von FrameworkElement ableiten damit das ganze im LogicalTree hängt?
Was passiert, wenn eine Level-klasse mal nicht im Shelf hängt und somit nicht das Merkmal "Inhalt" vererbt bekommt und drauf zugreifen möchte.


Vielen Dank und viele Grüße

Thema: Regal in WPF selber zeichnen
Am im Forum: GUI: WPF und XAML

Ich wollte nochmal meinen eingeschlagenden Weg aufzeichnen.

Zuerst hatte ich eine Klasse von Canvas abgeleitet und dann im Codebehind via DependencyProperties gezeichnet. War ganz ok. :) Aber ich mache jetzt folgendes:


Eine Klasse abgeleitet von Usercontrol.
Dann habe ich ein Stackpanel genommen und dort "stapel" ich RadioButtons die als DataTemplate der Ebenen herhalten. Die RadioButtons habe ich optisch per ControlTemplate angepasst. Jetzt sie ein RadioButton aus wie eine Ebene. Diese werden übereinander gestapelt. Somit habe ich auch die RadioButton Funktionalität zur Verfügung (was gewünscht war).
Im Codebehind habe ich ein DependencyProperty erzeugt. Das DependencyProperty nimmt ein Objekt des Typ "Shelf" also ein Regal.
Diese Klasse hatte ich ja schon und diese Klasse beschreibt ein Regal in Höhe und Breite und die Anzahl der Ebenen.
Im XAML greife ich eben auf das Object zu und lese die Werte aus.
Das ganze wäre natürlich auch ohne das DependencyObject möglich gewesen, indem ich einfach den DataContext des Elements auf die shelf Klasse setze.

Im Moment genügt es erstmal meinen Anforderungen.

@Abt: danke für den Hinweis. Das beschriebende Problem hatte ich schon oft :D

Thema: Regal in WPF selber zeichnen
Am im Forum: GUI: WPF und XAML

Hi,

an ein Stackpanel hatte ich auch schon gedacht da ja die Böden zusagen übereinander gestappelt werden. Ist ja nunmal so bei einem Schrank :D
Aber was ist, wenn ich irgendwann noch einmal etwas daneben zeichnen möchte? Zum Beispiel die Gesamthöhe mit einer Maßlinie.

Thema: Regal in WPF selber zeichnen
Am im Forum: GUI: WPF und XAML

Eigentlich soll nicht nur die Anzahl angegeben werden. Ein Abstand zum nächsten Boden wird auch noch benötigt. Eventuell auch die Farbe des Bodens.
Ich habe nur das Gefühl das es viele Wege gibt. Die ich alle im Moment nicht so wirklich durchblicke und nicht weiss was welcher Weg der Beste ist.

Thema: Regal in WPF selber zeichnen
Am im Forum: GUI: WPF und XAML

Zitat von malignate
Ich würde ein CustomControl erstellen und da wirst du dann einfach auf Änderungen in den Dependency Properties reagieren müssen.

Ok da sind wir uns da schon einmal einige. Das war auch mein Gedanke.
Zitat von malignate
Dann kannst du die Regelböden einfach per Code erzeugen. Anklicken kann man ja jedes Control und mit Trigger solltest man auch das Styling gut hinbekommen könnem.

Hierbei habe ich noch ein Problem.
Soll ich einfach im CodeBehind des Custom Controls so etwas machen:


Rectangle blueRectangle = new Rectangle();
blueRectangle.Height = 100;
blueRectangle.Width = 200;

und diese anschließend im Canvas oder wo auch immer positionieren.

Oder soll ich im XAML einen Button in der Resource anlegen und diesen stylen. Oder ein Rectangle anlegen und stylen. Im Codebehind würde ich diesen dann sehr oft erzeugen und positionieren.

Eine andere Idee kam mir auch noch. Über ein ItemsControl zu gehen:

        <ItemsControl ItemsSource="{Binding ShelfItems}">
            <ItemsControl.Resources>
                <DataTemplate DataType="{x:Type local:RectItem}">
                    <TextBlock Text="" TextAlignment="Center">
                        <Rectangle Width="{Binding Width}" Height="{Binding Height}" Stroke="{Binding Color}" StrokeThickness="2" Margin="2"/>
                    </TextBlock>
                </DataTemplate>
            </ItemsControl.Resources>
            <ItemsControl.ItemsPanel>
                <ItemsPanelTemplate>
                    <Canvas Background="WhiteSmoke"/>
                </ItemsPanelTemplate>
            </ItemsControl.ItemsPanel>
            <ItemsControl.ItemContainerStyle>
                <Style TargetType="ContentPresenter">
                    <Setter Property="Canvas.Left" Value="{Binding X}"/>
                    <Setter Property="Canvas.Top" Value="{Binding Y}"/>
                </Style>
            </ItemsControl.ItemContainerStyle>
        </ItemsControl>

und eben für andere Typen ein anderes DataTemplate anlegen. Dann werden die Element eines Regals einfach in eine ObservableCollection gepackt und angezeigt.

Thema: Regal in WPF selber zeichnen
Am im Forum: GUI: WPF und XAML

Hallo,

mir stellt sich folgende Aufgabe aber ich bin mir nicht ganz sicher wie ich diese Umsetzen soll und hoffe auf ein paar Gedankenanstöße von euch.

Ich habe eine WPF Anwendung. In dieser Anwendung soll ich ein Regal in der Frontansicht zeichnen. Bestehenden aus zwei Seitenteilen eben und den Einlegeböden. Eventuell das ganze auch noch in einer Holzfarbe einfärben.
Recht im Fenster befinden sich ein paar Textfelder. Dort kann man einstellen wie hoch und breit das Regal sein soll. Weiterhin kann die Einteilung eingestellt werden. Also wie viele Böden vorhanden sind und wie groß ihr Abstand zueinander ist.
Anschließend soll jeder Boden angeklickt werden können und gehighlited werden.

Wie mache ich das ganze in WPF?

Meine Gedankengeänge waren bisher wie folgt:

-ein eigenes UserControl erstellen oder von Canvas ableiten
-im CodeBehind neue DependencyProperties erstellen für Höhe, Breite, Anzahl der Böden
-im Codebehind dann selber Rechtecke zeichnen und positionieren, anhand der Merkmale
oder
-im Codebehind anhand der Merkmale RadioButtons erstellen und diese durch Styles und Templates so verändern das sie aussehen wie ein Regalboden, somit können diese angeklickt werden
oder
- RadioButtons im XAML erstellen Stylen und im Codebehind auf diese Resourcen zugreifen und das ganze anschliessen positionieren

Was wäre der Beste weg?
Mir ist einfach unklar wie ich am flexiblesten (damit es auch einfach erweiterbar ist) die einzelnen Böden/Ebenen darstellen soll. Weiterhin erschließt sich mir nicht wie das ganze dynamisch passieren soll (der Nutzer gibt ja de Anzahl ein). Und drittens so gemacht ist das der Nutzer die einzelnen ebenen anklicken kann.

Das ganze ist natürlich dann per MVVM an ein Model mittels ViewModel zu binden.
Eventuell soll das ganze irgendwann erweitert werden und links und rechts sollen Linien für die Bemaßung erscheinen.

Vielen Dank und viele Grüße

Thema: WPF - Architektur eines Programms zur Medienverwaltung
Am im Forum: Rund um die Programmierung

Hallo,

ich würde gerne ein Programm in WPF mit C# umsetzen.
Allerdings stellen sich mir da noch ein paar Fragen bzgl. dem Aufbau der Datenstrukturen und wie diese interagieren solleN. Eventuell hat ja der ein oder andere von euch einen Tipp.

Mit dem Programm sollen Medien sortiert werden: VHS, CD, DVD, BR, Bücher etc.
Bzw. das Programm soll am Ende etwas anderes sortieren ich erkläre aber die Bedingungen und das Verhalten an dem Medienbeispiel, das ist leichter zu verstehen.

Folgendes soll das Programm leisten:
- der Nutzer soll eine Individuelle Themengruppen erstellen können (z.B. Action)
- jede Themengruppen darf nur einmal existieren (der Name der Themengruppen)
- der Nutzer soll zu der Themengruppe die entsprechenden Artikel die er dort einsortieren möchte hinzufügen, z.B. über die ISBN
- jeder Artikel darf nur in eine Themengruppe
- der Nutzer soll eine Themengruppe selektieren können, anschließend sieht er alle Artikel darin und soll diese selektieren können, danach kann er einem Artikel eine Eigenschaft dynamisch/individuell zuweisen z.B. Dauer oder Spielzeit
- wenn einem Artikel in einer Gruppe eine Eigenschaft hinzugefügt wird dann muss allen anderen Artikeln in dieser Gruppe diese Eigenschaft auch angehangen und durch den Nutzer definiert werden
- jeder Artikel soll eindeutig definiert sein, das heißt um bei dem obigen Beispiel zu bleiben kann es keine zwei Artikel mit der selben Dauer/Spielzeit geben. Das soll dem Nutzer signalisiert werden das er das zu korrigieren hat.

Wie gesagt, es geht eigentlich nicht 100% um CDs und DVDs aber das veranschaulicht es gut.
Wie würdet ihr das Aufbauen?

Bisher habe ich eine Klasse "Arbeitsbereich". In dem werden die Themen in einer Liste angelegt.die Themen sind von der Klasse "Thema".
Die Medien sind von der Klasse "Medien" und können eine Liste von Eigenschaften der Klasse "MedienEigenschaft" halten.

Wenn ich jetzt einem Medium eine Eigenschaft hinzufüge, wie bekommen dann die anderen Medien in dem Thema mit das sie auch diese Eigenschaft besitzen? Oder soll das hinzufügen der Eigenschaft nicht am Medium sondern dann am Thema geschehen? Das selbe Problem besteht beim hinzufügen eines Mediums zu einem Thema? Soll der Arbeitsbereich es überwachen das Medien nur in ein Thema dürfen? Und wie bekommt das Thema mit das die Medien beim zuordnen der Eigenschaften nicht eindeutig definiert sind?

Ich könnte auch einfach anfangen und immer alles durch abchecken und durchlaufen von Themen-Listen prüfen aber eventuell habt ihr ja einen elganteren weg parat.

Vielen Dank für eure Vorschläge.

Thema: Eigenes UserControl verhält sich nicht wie ParentControl
Am im Forum: GUI: WPF und XAML

Ok,

dann erstelle ich zu dem zweiten Problem schon einmal selber eine Antwort. Ich habe das eben herausgefunden :)

Am ListView muss folgendes gesetzt werden:

ScrollViewer.HorizontalScrollBarVisibility="Disabled"

ItemTemplate sagt nur wie die Elemente gerendert werden sollen aber es hat keinen Effect auf das Layout. Das macht ja immer noch ListView wie es lustig ist.
So habe ich das zumindest verstanden und mir zusammen gereimt. :)

Thema: Eigenes UserControl verhält sich nicht wie ParentControl
Am im Forum: GUI: WPF und XAML

Hallo,

ich habe folgendes Problem. Ich habe ein Eigenes USerControl erstellt "ExtendedListview" das ganze leite von Listview ab. Es ist noch nichts weiter darin implementiert. Das Control wird auch in der Toolbox angezeigt.


public class ExtendedListView : ListView
{
}

Im XAML habe ich das original ListView so verwendet:

                <ListView ItemsSource="{Binding Personen}" Background="AliceBlue"  Grid.Row="1" Grid.RowSpan="1">
                    <ListView.ItemTemplate>
                        <DataTemplate>
                                <StackPanel>
                                    <TextBlock Text="{Binding Name}"/>
                                    <TextBlock Text="{Binding Alter}"/>
                                </StackPanel>
                        </DataTemplate>
                    </ListView.ItemTemplate>
                    <ListView.ItemsPanel>
                        <ItemsPanelTemplate>
                            <WrapPanel/>
                        </ItemsPanelTemplate>
                    </ListView.ItemsPanel>
                </ListView>

somit wurden die Element wunderbar nebeinander vom wrappanel dargestellt.

nutze ich aber das gleiche Beispiel mit meinem ExtendedViewList geht nix :(

                <local:ExtendedListView ItemsSource="{Binding Personen}" Background="AliceBlue"  Grid.Row="1" Grid.RowSpan="1">
                    <local:ExtendedListView.ItemTemplate>
                        <DataTemplate>
                            <StackPanel>
                                <TextBlock Text="{Binding Name}"/>
                                <TextBlock Text="{Binding Alter}"/>
                            </StackPanel>
                        </DataTemplate>
                    </local:ExtendedListView.ItemTemplate>
                    <local:ExtendedListView.ItemsPanel>
                        <ItemsPanelTemplate>
                            <WrapPanel/>
                        </ItemsPanelTemplate>                        
                    </local:ExtendedListView.ItemsPanel>
                </local:ExtendedListView>

Nichtmal der gesetzte Hintergrund wird aktiv.

Füge ich aber folgendes hinzu (was durch den automatisch erzeugen Code von Visual Studio dabei war:

                    <local:ExtendedListView.View>
                        <GridView>
                            <GridViewColumn/>
                        </GridView>
                    </local:ExtendedListView.View>

sehe ich den hintergrund aber natürlich greift dann mein Template nicht und die Elemente werden nicht so dargestellt wie ich es vorher wollte.

Woran liegt das?

Vielen Dank.

Edit:
Ein weiteres Problem kommt noch hinzu. Mir fällt gerade auf das die Elemente nicht "Wrappen" trotz der Verwendung eines WrapPanels. Woran liegt das? ISt der oben gewählte Ansatz generell falsch?
Mein Ziel war eine Listview zu haben indem Elemente als Bilder dargestellt werden (im moment wid das noch nicht gemacht) und von links nach rechts und oben nach unten angeordnet sind.

Thema: View mit ViewModel verbinden
Am im Forum: GUI: WPF und XAML

Hallo,

Vielen Dank erstmal für die rege Beteiligung zu meiner Frage
Ich bin die Tage unterwegs und nicht an meinem Computer. Deshalb kann ich nur an meinem Handy kurz mitlesen und antworten.
Wenn ich zurück bin werde aber mal all eure Informationen durcharbeite.

Ich will nur noch einmal kurz meine Situation aufgreifen die ich kurz beschrieb bevor andere hier diskutiert haben

Also meine erste Frage war ja das Verbinden von View und ViewModel. Ich denke das hat sich erledigt.

Der zweite Teil der wohl etwas zur Verwirrung beigetragen hat war folgendes.
Ich habe im Visual Studio als Startprojekt keine WPF Anwendung gewählt sondern eine dll.
Die Anwendung ist nämlich ein Plugin für eine andere Anwendung. Diese Anwendung lädt die dll
Und erwartet eine Methode namens show(). Darin kann ich mich austoben. Also erstelle ich dort eine Instanz eines WPF Fensters und zeige dieses per ShowDialog() an. Soweit ist doch alles ok. Da kann ich ja nicht anders herangehen, wenn die Pluginschnittstelle so ist. (Denn weiter oben meinte jemand das sei schon faul).
Wenn jetzt der Dialog geschlossen wird dann wollte ich irgendwie an den Inhalt der Textfelder ran kommen und da stellte sich mir eben die Frage was das beste ist. Denn das Ergebnis muss über das Plugin an das Programm zurück geschickt werden.

Oh man. Jetzt ist hier wieder viel Text draus geworden. Ich hoffe es ist klar und nicht verwirrender geworden

Vielen Dank und viele Grüße

P.S. Vielen Dank für die Links "wie rufe ich einen Dialog aus einem Dialog unter WPF auf" das war sehr informativ.

Thema: View mit ViewModel verbinden
Am im Forum: GUI: WPF und XAML

Zitat von Th69
Hallo,

du solltest bei MVVM nur im ViewModel Code haben und dieser sollte auch nur mit anderen ViewModels kommunizieren (d.h. niemals eine View direkt aufrufen o.ä.).

Das ist mir schon klar und das ist ja auch in meinem Fall so. Das ViewModel ruft NICHT seinen eigenen View auf. Auch ruf kein anderes ViewModel das View auf. Das View wird einfach in einer Main-Klasse geladen und angezeigt. Dies main-klasse ist der Einstieg in das"Programm". Dies befindet sich in einer dll und wird durch ein anderes Programme geladen.

Ich lese mal die beiden von dir verlinkten Artikel, eventuell ist ja etwas für mich dabei.

Viele Grüße