c# projekt

el-nino · 2. Mai 2014

hoi zäme

ich darf für ein schulprojekt ein programm in c# (visual studio) schreiben. es geht darum eine maschine zu visualisieren. ich werde wohl hie und da ein paar grundsatzfragen haben wo mir einfach das schlagwort fehlt um danach zu googlen. für die profis unter euch wird es aber wohl einfach zu beantworten sein, daher erlaube ich mir hier nachzufragen.

das GUI wird grundsätzlich immer gleich aussehen. oben den status, unten buttons um zwischen den einzelnen seiten zu wechseln. wie realisiere ich das am besten dass ich die einzelnen seiten im VS zeichnen kann? ich kann ja nicht alles auf eine seite zeichnen und dann ausblenden was ich atm nicht brauche. für jede seite einen thread zu erstellen finde ich aber auch etwas zu aufwändig.

click auf button Seite 1 zeigt Seite 1 an:

click auf button Seite 2 zeigt Seite 2 an:

BLJ · 2. Mai 2014

WPF und MVVM anwenden mit einem gescheiten Framework, z.B. Caliburn.Micro

Dazu natürlich dependency injection, z.B. Ninject

Dann kannst du ganz einfach ein View-Element an ein ViewModel Property binden. Auswechseln des ViewModel-Property wechselt die View... ("Seite")

GP · 5. Mai 2014

Wenn auch 3 Tage später, aber dem kann ich mich anschliessen

Ein weiteres Framework für MVVM ist MVVM Light. Aber bevor du da beginnst, mach dich mit dem MVVM Designpattern vertraut. Klingt im ersten Schritt vielleicht nach Aufwand, aber es lohnt sich garantiert - nicht nur für dieses Projekt.

Kurz und sehr vereinfacht gesagt hast du eine Ansicht (das Layout des Programmes, wie bereits gepostet) und angezeigte Daten. Diese Daten werden an das Design 'gebunden' und so sieht man auf Seite 1 jeweils das, was du in der entsprechenden Variable gespeichert hast. Du musst dich also absolut im nichts visuelles kümmern, einfach deine Daten aktualisieren und fertig.

Hier findest du ein Beispiel mit zwei Seiten und zwei Buttons, um zwischen den Seiten zu wechseln. Also genau das, was du da gepostet hast.

el-nino · 19. Juni 2014

danke für die antworten, ich mache kleine schritte vorwärts

eine weitere frage: ich möchte einen button mit mehr funktionalität versehen. ich könnte also einfach von Button erben und entsprechend erweitern richtig?

Code

class MyButton : Button{}

wie kann ich nun aber buttons in xaml als MyButton einfügen anstatt als Button? also wie werden die Buttons zu MyButtons?

BLJ · 19. Juni 2014

Namespace importieren und dann machst du <myNamespace:MyButton/>

Welche Funktionalität möchtest du denn genau hinzufügen? Vielleicht lässt sich das auch anders als per Vererbung realisieren. Vererbung ist leider im UI Bereich noch sehr verbereitet. "Favor composition over inheritance"!

el-nino · 23. Juni 2014

mein programm wird zu einer sps verbinden. somit möchte ich buttons, labels etc. erstellen, welche bereits über bestimmte funktionalitäten zum verbinden auf die sps verfügen. so dass ich beim erstellen eines buttons z.b. einen variablennamen mitgeben kann, um dann diese variable auf der sps zu togglen. macht hier vererbung sinn?

das programm muss mehrsprachig sein, hier bin ich aber noch am kämpfen. gemäss diversen tutorials soll es nicht so kompliziert sein, evtl. verstehe ich aber etwas grundsätzlich falsch. was ich bereits gemacht habe:
1. in der projektdatei folgende zeile hinzugefügt:

Code

<PropertyGroup>
..
<UICulture>de-DE</UICulture>
</PropertyGroup>

2. in der AssemblyInfo.cs folgende zeile hinzugefügt:

Code

[assembly: NeutralResourcesLanguage("de-DE", UltimateResourceFallbackLocation.Satellite)]

3. zwei ressource-dateien angelegt und diese auf public gestellt:

4. im xaml der entsprechenden view einen neuen namesraum lang definiert:

5. will ich den text nun aber z.b. bei einem textblock verwenden, bekomme ich den error:

was mache ich falsch?

BLJ · 23. Juni 2014

poste mal den generierten Code von Allgemein.resx.cs

el-nino · 23. Juni 2014

Code

//------------------------------------------------------------------------------
// <auto-generated>
// Dieser Code wurde von einem Tool generiert.
// Laufzeitversion:4.0.30319.18444
//
// Änderungen an dieser Datei können falsches Verhalten verursachen und gehen verloren, wenn
// der Code erneut generiert wird.
// </auto-generated>
//------------------------------------------------------------------------------
namespace BFH.TexteSprachen {
using System;
/// <summary>
/// Eine stark typisierte Ressourcenklasse zum Suchen von lokalisierten Zeichenfolgen usw.
/// </summary>
// Diese Klasse wurde von der StronglyTypedResourceBuilder automatisch generiert
// -Klasse über ein Tool wie ResGen oder Visual Studio automatisch generiert.
// Um einen Member hinzuzufügen oder zu entfernen, bearbeiten Sie die .ResX-Datei und führen dann ResGen
// mit der /str-Option erneut aus, oder Sie erstellen Ihr VS-Projekt neu.
[global::System.CodeDom.Compiler.GeneratedCodeAttribute("System.Resources.Tools.StronglyTypedResourceBuilder", "4.0.0.0")]
[global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
[global::System.Runtime.CompilerServices.CompilerGeneratedAttribute()]
public class Allgemein {
private static global::System.Resources.ResourceManager resourceMan;
private static global::System.Globalization.CultureInfo resourceCulture;
[global::System.Diagnostics.CodeAnalysis.SuppressMessageAttribute("Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode")]
internal Allgemein() {
}
/// <summary>
/// Gibt die zwischengespeicherte ResourceManager-Instanz zurück, die von dieser Klasse verwendet wird.
/// </summary>
[global::System.ComponentModel.EditorBrowsableAttribute(global::System.ComponentModel.EditorBrowsableState.Advanced)]
public static global::System.Resources.ResourceManager ResourceManager {
get {
if (object.ReferenceEquals(resourceMan, null)) {
global::System.Resources.ResourceManager temp = new global::System.Resources.ResourceManager("BFH.TexteSprachen.Allgemein", typeof(Allgemein).Assembly);
resourceMan = temp;
}
return resourceMan;
}
}
/// <summary>
/// Überschreibt die CurrentUICulture-Eigenschaft des aktuellen Threads für alle
/// Ressourcenzuordnungen, die diese stark typisierte Ressourcenklasse verwenden.
/// </summary>
[global::System.ComponentModel.EditorBrowsableAttribute(global::System.ComponentModel.EditorBrowsableState.Advanced)]
public static global::System.Globalization.CultureInfo Culture {
get {
return resourceCulture;
}
set {
resourceCulture = value;
}
}
/// <summary>
/// Sucht eine lokalisierte Zeichenfolge, die Sicherheit ähnelt.
/// </summary>
public static string SafetyLabel {
get {
return ResourceManager.GetString("SafetyLabel", resourceCulture);
}
}
/// <summary>
/// Sucht eine lokalisierte Zeichenfolge, die Einrichten ähnelt.
/// </summary>
public static string SetupLabel {
get {
return ResourceManager.GetString("SetupLabel", resourceCulture);
}
}
}
}

Alles anzeigen

el-nino · 2. Juli 2014

sali zäme

bin wieder ein schritt weiter. ich habe ein mvvm-grundgerüst mit mvvm-light erstellt welches grundsätzlich funktioniert. ich kann also recht einfach views (usercontrols) switchen. soweit so gut.

nun, wie gesagt muss die anwendung mehrsprachig sein. ich bin nun soweit, dass ich die sprache zur runtime wechseln kann. ich habe dazu diverse tutorials und beispiele gelesen und mir das nötige dazu zusammenkopiert. nun stehe ich in app.xaml vor einem problem.

so sah der code aus dem mvvm-grundgerüst aus:

Code

<Application x:Class="BFH02.App"
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:views="clr-namespace:BFH.View"
xmlns:vm="clr-namespace:BFH.ViewModel"
xmlns:culture="clr-namespace:BFH02.Cultures"
xmlns:local="clr-namespace:BFH02"
StartupUri="MainWindow.xaml"
mc:Ignorable="d">
<Application.Resources>
<DataTemplate DataType="{x:Type vm:HomeViewModel}">
<views:HomeView />
</DataTemplate>
<vm:ViewModelLocator x:Key="Locator" d:IsDataSource="True" xmlns:vm="clr-namespace:BFH02.ViewModel" />
</Application.Resources>
</Application>

Alles anzeigen

diesen code brauche ich im app.xaml für die lokalisierung:

Code

<Application.Resources>
<ResourceDictionary>
<ResourceDictionary.MergedDictionaries>
<ResourceDictionary Source="ResourceDictionary1.xaml"/>
</ResourceDictionary.MergedDictionaries>
</ResourceDictionary>
</Application.Resources>
</Application>

Alles anzeigen

nun, wie füge ich beides zusammen? folgender code lässt sich kompilieren, ich sehe aber meine erste view nicht mehr...

Code

<Application.Resources>
<ResourceDictionary>
<ResourceDictionary.MergedDictionaries>
<ResourceDictionary Source="ResourceDictionary1.xaml"/>
</ResourceDictionary.MergedDictionaries>
<DataTemplate DataType="{x:Type vm:HomeViewModel}">
<views:HomeView />
</DataTemplate>
<vm:ViewModelLocator x:Key="Locator" d:IsDataSource="True" xmlns:vm="clr-namespace:BFH02.ViewModel" />
</ResourceDictionary>
</Application.Resources>

Alles anzeigen

BLJ · 4. Juli 2014

nein nein nein
Die Struktur des Baumes muss erhalten beiben. Du kannst nicht die existierenden Elemente einfach an ein anderes neues anhängen.

Das heisst die DataTemplate, vm:ViewModelLocator und ResourceDictionary Nodes kommen alle direkt unter Application.Resources:

Code

<Application.Resources>
<DataTemplate DataType="{x:Type vm:HomeViewModel}">
<views:HomeView />
</DataTemplate>
<vm:ViewModelLocator x:Key="Locator" d:IsDataSource="True" xmlns:vm="clr-namespace:BFH02.ViewModel" />
<ResourceDictionary>
<ResourceDictionary.MergedDictionaries>
<ResourceDictionary Source="ResourceDictionary1.xaml"/>
</ResourceDictionary.MergedDictionaries>
</ResourceDictionary>
</Application.Resources>

Alles anzeigen

EDIT: Tipp: Stackoverflow.com hat viele Probleme schon einmal abgedeckt. Und Fragen stellen ist da auch kostenlos und es kommen ziemlich schnell antworten (je nach Thema und wie gut die Frage beschrieben ist)

el-nino · 8. Juli 2014

es geht vorwärts für die mehrsprachigkeit habe ich mittlerweile eine lösung.

nun zu meinen buttons und labels: ich möchte buttons und labels mit mehr funktionalität versehen. deshalb erstelle ich eigene. wie bringe ich diese nun in mein xaml? <myNamespace:MyButton/> funktioniert, aber nur wenn ich dem constructor keine parameter übergebe. ich möchte aber noch parameter mit geben, wie geht das?

habe die frage auch hier gepostet: http://stackoverflow.com/quest…rit-label-with-parameters

el-nino · 8. Juli 2014

ist hier jemand richtig vertraut mit wpf und arbeitet viel damit? ich denke, ich würde viel profitieren wenn ich mit jemandem von euch vielleicht mal einen halben tag zusammensitzen könnte um die diversen punkte zu besprechen. schlussendlich ist es ja nichts kompliziertes was ich machen will

ich denke ich brauche einfach an ein paar orten einen schubs in die richtige richtung.

GP · 8. Juli 2014

Ich hab den Code nur kurz überflogen, aber für die zusätzliche Funktionalität würde ich die zu ändernden Eigenschaften der Elemente der View an eine Property des ViewModels binden. So kannst du aus der Programmlogik heraus alles mögliche ändern, ohne dass du dazu die Elemente erweitern musst.

Sobald ich an einem PC bin, kann ich das als Code zur Illustration posten

Im der View XAML

Zitat

<Label Content="Blabla" Foreground="{Binding ForegroundColor}"/>

im ViewModel

Zitat

//Member
private SolidColorBrush _foregroundColor;
//Property
public SolidColorBrush ForegroundColor
{
get
{
return _foregroundColor;
}
set
{
if (_foregroundColor== value)
return;
_foregroundColor= value;
RaisePropertyChanged("ForegroundColor");
}
}

//Irgendwo im Code dann
StatusBackground = Brushes.//FARBE

Alles anzeigen

Durch das Databinding wird die Farbe an die Eigenschaft im XAML gebunden und durch das PropertyChanged-Event jeweils beim Verändern der Variable aktualisiert.

el-nino · 9. Juli 2014

wenn ich das so mache bekomme ich die meldung:
Der Name 'RaisePropertyChanged' ist im aktuellen Kontext nicht vorhanden.

du schreibst, ich solle deinen code in mein viewmodel integrieren. ich habe dazu aber eine eigene klasse erstellt, ich möchte myLabel ja in mehreren views (und somit auch viewmodels?) verwenden können.

weiter frage ich mich, wie ich danach die farbe eines bestimmten labels im code verändern kann? ich möchte ja nicht mit alle labels an dieselbe farbe binden.

hier meine dateistruktur. die klasse mit meinem label heisst LabelSPSColor.cs

so habe ich das label im xaml integriert:

Code

<sps:LabelSPSColor x:Name="testSPSLabelColor" Content="SPSLabelColor" LabelActiveBrush="LightBlue" LabelInactiveBrush="Gray"
LabelSPSVariable="bTest" Foreground="{Binding ForegroundColor}"/>

so sieht die klasse aus:

Code

public class LabelSPSColor : Label
{
#region Members
private Brush _foregroundColor;
#endregion
#region Properties
public Brush ForegroundColor
{
get { return _foregroundColor; }
set
{
if (_foregroundColor == value)
return;
_foregroundColor = value;
RaisePropertyChanged("ForegroundColor");
}
}
public Brush LabelActiveBrush
{
get { return (Brush)GetValue(LabelActiveBrushProperty); }
set { SetValue(LabelActiveBrushProperty, value); }
}
public static readonly DependencyProperty LabelActiveBrushProperty =
DependencyProperty.Register("LabelActiveBrush", typeof(Brush), typeof(LabelSPSColor), new UIPropertyMetadata(Brushes.LightGreen));
public Brush LabelInactiveBrush
{
get { return (Brush)GetValue(LabelInactiveBrushProperty); }
set { SetValue(LabelActiveBrushProperty, value); }
}
public static readonly DependencyProperty LabelInactiveBrushProperty =
DependencyProperty.Register("LabelInactiveBrush", typeof(Brush), typeof(LabelSPSColor), new UIPropertyMetadata(Brushes.Gray));
public String LabelSPSVariable
{
get { return (String)GetValue(LabelSPSVariableProperty); }
set { SetValue(LabelSPSVariableProperty, value); }
}
public static readonly DependencyProperty LabelSPSVariableProperty =
DependencyProperty.Register("LabelSPSVarible", typeof(String), typeof(LabelSPSColor), new UIPropertyMetadata(string.Empty));
#endregion
#region Constructor
/// <summary>
/// Contructor
/// </summary>
public LabelSPSColor()
{
_foregroundColor = LabelActiveBrush;
}
#endregion
}

Alles anzeigen

GP · 9. Juli 2014

Wenn du nur so Sachen wie Farbe (Vorder-/Hintergrund), Text, etc aus dem Programm verändern willst, kannst du die ganze Erweiterung des Labels entfernen.

Vorab, das MVVM-Pattern klingt recht einfach und einleuchtend, aber bis man es wirklich verstanden hat, dauert es doch seine Zeit. Zwei Grundpfeiler des Patterns:

- Dynamische Inhalte (auch Farben und Eigenschaften) der View werden per Databinding aus dem ViewModel eingebunden
- Aktionen in der View lösen einen Command im ViewModel aus

Wenn das noch zu sehr nach Bahnhof klingt, mach dich unbedingt mit der Theorie des Patterns vertraut.

Zu deinem Problem:
Ich würde das SPS-Label nicht vom Label ableiten und erweitern, wie man es in anderen Sprachen macht. Es braucht wie im oberen Post erwähnt, viel viel weniger.

- Überall, wo dieses Label in der View verwendet wird, erstellst du ein ganz normales Label und bindest die zu verändernden Eigenschaften per Databinding an Properties deines ViewModels.
- Im ViewModel musst du du diese Properties hinzufügen und sie bei einer Änderung des Wertes jeweils einen Event auslösen lassen, damit die View benachrichtigt wird, dass die jeweilige Eigenschaft geändert wurde.

Wenn du MVVM-Light verwendest und im ViewModel "using GalaSoft.MvvmLight;" einfügst, dann steht dir die Klasse "ObservableObject" zur Verfügung. Diese stellt dir das Event "RaisePropertyChanged" zur Verfügung

el-nino · 9. Juli 2014

besten dank für deine hilfe soweit GP! es ist genau wie du sagst, einleuchtend und logisch ist es schnell mal, bis man aber weis wie anwenden dauert es. im moment finde ich das ganze noch unnötig kompliziert

ich werde die ganze geschichte morgen mal umbauen es so versuchen.

BLJ · 10. Juli 2014

Zitat

Original von el-nino
wenn ich das so mache bekomme ich die meldung:
Der Name 'RaisePropertyChanged' ist im aktuellen Kontext nicht vorhanden.
[/code]

Ja das war wohl ein psuedo Code Beispiel
Die Method musst du dir selbst denken. Es gibt sie z.T. in WPF GUI Libraries / Frameworks wie Caliburn.Micro in Basisklassen (z.B. Screen), also wenn dein ViewModel : Screen implementiert geht das.

Siehe hier: http://msdn.microsoft.com/en-u…hanged%28v=vs.110%29.aspx

Das erklärt für was das interface gedacht ist (Notifications aus GP's Grafik).

Es gibt sonst auch noch PropertyChanged.Fody, das nimmt dir die Implementation des Property Changed fast vollständig ab.

https://www.nuget.org/packages/PropertyChanged.Fody/

(aber es ist wohl besser wenn dus zuerst mal selbst implementierst um zu verstehen wie das funktioniert).

el-nino · 10. Juli 2014

ich glaube ich stehe kurz vor dem durchbruch

so habe ich das label erstellt

Code

<Label Content="HomeView" Background="{Binding BackgroundColor}" />

und ein button zum testen

Code

<Button Content="TestSPS" Height="50" Width="50" Command="{Binding TestLabelCommand}" />

das ist mein viewmodel:

Code

public class HomeViewModel : ViewModelBase
{
#region Members
private Brush _backgroundColor;
#endregion
#region Properties
public Brush BackgroundColor
{
get { return _backgroundColor; }
set
{
if (_backgroundColor == value)
return;
_backgroundColor = value;
RaisePropertyChanged("BackgroundColor");
}
}
#endregion
#region commands
public ICommand TestLabelCommand { get; private set; }
#endregion
/// <summary>
/// Initializes a new instance of the HomeViewModel class.
/// </summary>
public HomeViewModel()
{
TestLabelCommand = new RelayCommand(() => ExecuteTestLabelCommand());
_backgroundColor = Brushes.Brown;
}
private void ExecuteTestLabelCommand()
{
if (ConnectSPS.Read_BOOL_fromSPS("MAIN.bTest"))
{
_backgroundColor = Brushes.Green;
MessageBox.Show("TRUE");
}
else
{
_backgroundColor = Brushes.Red;
MessageBox.Show("FALSE");
}
}
}

Alles anzeigen

die verbindung zur sps funktioniert, ich bekomme die messagebox mit TRUE oder FALSE je nach zustand der variable in der SPS. das kommando wird also ausgeführt, aber die farbe ändert leider noch nicht... sie ist beim start brown, wie im constructor vom viewmodel definiert, aber sie ändert sich danach nicht mehr. wo hängts noch?

nun noch etwas zu MVVM: meine daten (kommen ja mehrheitlich aus der sps) wären nun eigentlich nach MVVM die models richtig? somit halte ich mich nicht an MVVM wenn ich direkt aus dem VM via meiner klasse connectSPS (diese beinhaltet die funktionen zum lesen und schreiben auf die sps) auf die daten zugreife richtig?

GP · 10. Juli 2014

el-nino: Das sieht schon sehr gut aus! Der einzige Fehler ist folgender:
Du hast eine Property (BackgroundColor) erstellt, welche das Schreiben und das Lesen der Variable _backgroundColor regelt, um diese Funktionalitäten eben genau mit dem Abfeuern des Events zu erweitern.
Aus diesem Grund darfst du im ganzen Code nur über diese Property die Variable manipulieren, nicht die Variable selbst. Du musst also nur folgende zwei Zeilen ersetzen

_backgroundColor = Brushes.Green; durch BackgroundColor = Brushes.Green;

_backgroundColor = Brushes.Red; durch BackgroundColor = Brushes.Red;

Zitat

Original von BLJ

Ja das war wohl ein psuedo Code Beispiel
Die Method musst du dir selbst denken. Es gibt sie z.T. in WPF GUI Libraries / Frameworks wie Caliburn.Micro in Basisklassen (z.B. Screen), also wenn dein ViewModel : Screen implementiert geht das.

Er benutzt das MVVM-Light Framework, dort ist das alles schon implementiert. Aber ich gebe dir Recht, fürs Verständnis wäre es besser, das alles selbst zu machen

el-nino · 14. Juli 2014

es geht immer besser

da die software auch über touch-screen bedient werden kann habe ich eine eigene input-box geschrieben. diese erscheint sobald die textbox angeklickt wird. es gibt sie in zwei versionen (zwei konstruktoren), einmal für text und einmal für zahlen. eine entsprechende validierung habe ich auch programmiert. funktioniert soweit ganz gut. dazu habe ich aber noch eine frage:

aufgerufen wird das ganze so:

in der view:

Code

<TextBox.InputBindings>
<MouseBinding Command="{Binding TestTextBoxCommand}" MouseAction="LeftClick" />
</TextBox.InputBindings>

im konstrutkor vom viewmodel:

Code

TestTextBoxCommand = new RelayCommand(() => ExecuteTestTextBoxCommand());

die entsprechende methode:

Code

private void ExecuteTestTextBoxCommand()
{
var dialog = new BFH.InputBox.InputBox("Titel", "bitte um Eingabe");
dialog.ShowDialog();
TestTextBoxString = dialog.Input;
}

muss ich das jetzt wirklich für jede einzelne textbox einzeln so implementieren? das wäre doch ein schritt zurück... ich möchte code doch wiederverwenden können. ist es möglich, das objekt mitzugeben welches das command ausgelöst hat? ich mache es so bei meiner input-box um anhand des names des buttons den entsprechendenen buchstaben hinzuzufügen:

Code

private void Key_Click(object sender, RoutedEventArgs e)
{
var button = (Button)sender;
....