KeeperOfCoffee

Ich frage auch ständig Leute nach ihrer SteamId, aber jeder guckt mich nur komisch an tsts Desweiteren haben viele Leute ein Problem mit meinem Humor

Weiß @StefanE ja gleich was er machen kann, sollte hier das Geschäft mit den Stellenanzeigen nicht mehr laufen.

So von wegen Negativ und Negativ ist Positiv?

Vlt. meint er ja das gute alte VBA

Und durch die Batterieherstellung sind wir was die Umwelt angeht wieder bei +/- 0... Bloß das dies halt nicht in Deutschland passiert...kaufen wir aus China...noch dazu die schlechten Bedingungen in den Lithium und Kobaltminen...aber darüber redet man ja nicht.

Pfff E-Autos....Wasserstoff ist die Zukunft

MVVM wurde durch Microsofts Software Architekten Ken Cooper und Ted Peters erfunden. MVVM ist ein Software-Architekturpattern welches die Trennung der Entwicklung der UI von der Entwicklung der Geschäftslogik oder der Back-End Logik ermöglicht. Hierbei ist das "ViewModel" die Klasse die sozusagen sämtliche Daten und auch Methoden besitzt. Wenn du also ein vorgegebenes Model hast (z.B. aus einer Datenbank), dann stellst du sämtliche Daten die du benötigst hier dar bzw. arbeitest hier mit diesen. Auch Anzeigelogik wird hier gesteuert. Sagen wir du hast einen Button, der nur unter verschiedenen Konditionen Enabled werden soll. Du hast die View erstellt (das Markup) und bei "IsEnabled" hast du ein entsprechendes Binding erstellt. Wie dieses Binding lautet muss der Entwickler des Businesslogik wissen. Er entwickelt die Logik die sicherstellt, ob dieser Button Enabled ist. Der UI Entwickler kann sich um andere Dinge kümmern. MVVM findest du in .NET, Silverlight, Angular, Vue.js. JavaFX (habe ich mal gehört jedenfalls) und anderen Frameworks. Wenn man mit WPF arbeitet (also mit XAML), dann definiert der DataContext, mit welcher Klasse die aktuelle View sozusagen verbunden ist. Oben habe ich ja denn Fall mit dem Button und IsEnabled beschrieben. Das Markup muss ja wissen, wo der derzeitige Wert für IsEnabled dieses Buttons ist. Dieser befindet sich als bool in der entsprechenden Klasse, zusammen mit Logik die den Wert dieses bools verändern kann. Ist ein Standardinterface von .NET. Wird gebraucht für das OnPropertyChanged, welches die UI mitteilt, dass ein Property sich verändert hat: https://docs.microsoft.com/de-de/dotnet/api/system.componentmodel.inotifypropertychanged?view=netframework-4.7.2 https://docs.microsoft.com/de-de/dotnet/api/system.collections.objectmodel.observablecollection-1?view=netframework-4.7.2 da wie du siehst, diese bereits INotifyPropertyChanged implementieren. Das bedeutet, sehr vereinfacht gesagt, die OC WEIß wenn ein Element der OC sich verändert hat und gibt diese Info auch an die UI weiter. Ein Aufruf von OnPropertyChanged ist also auf eine OC nicht nötig. Wenn du eine normale List verwenden würdest, müsstest du bei jeder Operation, die diese Liste betrifft, ein OnPropertyChanged verwenden, damit die Klasser der UI weitergibt, dass die List sich verändert hat. Mich würden auch mal @Errraddicator und @Whiz-zarD Meinung hier interessieren, ihr postet doch öfters in C# Themen. In deinem Fall bräuchtest du also Bindings auf deinen Dargestellten Text, Commands für die Buttons, und ein ViewModel welches die Properties darstellt für die TextBindings und den Commands.

Ich würde es an deiner Stelle in ein MVVM umbauen, wie in meinem Post beschrieben. Aktuell machst du eher ein WPF-Projekt in WinForms-Stil.

Ja kann ich für meine Fälle nie nutzen, dafür habe ich diese schöne Sache public void CreateNewWindow<T>(double height, double width, string title, Type t, object vm) where T : new() { var svm = Convert.ChangeType(vm, t); var fenster = new T() as Window; fenster.DataContext = svm; fenster.Height = height; fenster.Width = width; fenster.Title = title; fenster.WindowStartupLocation = WindowStartupLocation.CenterScreen; fenster.ShowDialog(); } geht nur nicht wenn ich ne View mit Parameter initialisiere, passiert aber selten

Wir brauchen echt die Info, wie du es machen willst. Es gibt mehrere Wege etwas in WPF zu machen. Wenn du MVVM lernen willst, bräuchtest du ne Klasse (ViewModel) die mit den ganzen Daten arbeitet. Dann hättest du in deiner UI nur noch Verweise (Bindings) auf die Daten und Befehle. In MVVM würde es (kurz unsauber hingeklatscht, weil ich selbst auch noch arbeiten muss ) etwa so aussehen: public class Klasse : INotifyPropertyChanged { public event PropertyChangedEventHandler PropertyChanged; [NotifyPropertyChangedInvocator] protected virtual void OnPropertyChanged([CallerMemberName] string propertyName = null) { PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(propertyName)); } public string Eingabe { get; set; } public string Ausgabe { get; set; } public ICommand Tuwas => new RelayCommand(o => true, o => aufgehts()); private void aufgehts() { Ausgabe = "Test"; OnPropertyChanged(nameof(Ausgabe)); } } <Window x:Class="WpfApp1.MainWindow" 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:WpfApp1" mc:Ignorable="d" Title="MainWindow" Height="450" Width="800"> <Grid> <TextBlock Text="{Binding Ausgabe, UpdateSourceTrigger=PropertyChanged}" HorizontalAlignment="Left" VerticalAlignment="Top"></TextBlock> <TextBox Text="{Binding Eingabe}" HorizontalAlignment="Left" VerticalAlignment="Top" Width="68" Margin="96,55,0,0"></TextBox> <Button Command="{Binding Tuwas}" Content="Klick Mich" HorizontalAlignment="Left" VerticalAlignment="Top" Margin="96,78,0,0"></Button> </Grid> </Window> public partial class MainWindow : Window { public MainWindow() { InitializeComponent(); this.DataContext = new Klasse(); } } public class RelayCommand : ICommand { private Predicate<object> _canExecute; private Action<object> _execute; public RelayCommand(Predicate<object> canExecute, Action<object> execute) { this._canExecute = canExecute; this._execute = execute; } public event EventHandler CanExecuteChanged { add { CommandManager.RequerySuggested += value; } remove { CommandManager.RequerySuggested -= value; } } public bool CanExecute(object parameter) { return _canExecute(parameter); } public void Execute(object parameter) { _execute(parameter); } } Wobei hier nicht alles schön ist. Ich setze den DataContext ungerne ins Codebehind. Wie gesagt wir müssen wissen welche Technologie bzw. wie du deine Lösung anstrebst. Wenn du Event basiert arbeiten willst, dann kannst du eigentlich gleich bei WinForms bleiben, dass ist nämlich so ziemlich der WinForms Style. Ein anderer Weg ist auch, CommandBindings in der UI zu definieren, die auf ein Event im CodeBehind zeigen. Gibt viele Wege...manche werden als sehr unsauber angesehen. Edit: Der Code oben gibt nur was aus und soll dir ne Idee geben wie sowas aussehen kann. RelayCommand dient vereinfacht gesagt zum Ausführen von Aktionen. OnPropertyChanged dient vereinfacht gesagt um zu "melden" dass man ein Property geändert hat (du siehst das in der UI ein UpdateSourceTrigger ist der auf PropertyChanged eingestellt ist). Ich würde es jetzt gerne ausführlicher erklären, aber wie gesagt: Ich muss arbeiten

Bei mir war es eig. so: Jedesmal wenn ich einen Commit gemacht habe gab es dazu ne recht ausführliche Commit Message. Ich habe dann in *hust* recht großen Abständen die Commit Logs von Subversion geladen und mir daraus ein recht gutes Berichtsheft gebaut. Andere haben es ähnlich gemacht, sie haben ständig was in ihren Kalender reingeschrieben. Ich wollte den aber nicht zumüllen. Im Berichtsheft waren bei uns ganze Sätze vorgeschrieben. Mein Ausbilder und ich haben dann kurz zusammen monatlich (manchmal auch später) das Berichtsheft durchgegangen, da er wusste wie man manche Dinge besser beschreibt (war da anfangs recht unbeholfen was die IHK da genau will (wie detailliert usw. habe da im ersten Jahr schon von Anfang an alles Mögliche programmiert). Natürlich war das alles nicht optimal. Am Ende hatte ich aber ein recht ordentliches Berichtsheft. Schöner Ordner, jede Seite in Klarsichtsfolie, keine Rechtsschreibfehler....kein Prüfer hatte irgendwas auszusetzen oder irgendwelche Fragen. Mein Betrieb selbst hatte am Ende auch kaum was daran auszusetzen, da schon bekannt war, dass ich gehen werde. War also reine Formsache.

Die zweite Aktion geht echt mal gar nicht. Ich würde schauen da so schnell wegzukommen wie nur möglich. Bei der ersten Aktion war mein Gedanke, dass dich evtl. jemand sich über dich beschwert hat. Hast du Leute dort mit denen du dich nicht gut verstehst, die so etwas tun würden? Jedenfalls Daumen hoch, dass du dich da nicht unterkriegen lässt

Das kann man drehen wie man will größere Algorithmen werden in Sachen Performance gegenüber einer Storen Procedure immer den kürzeren ziehen imo.

Toll du lernst jetzt VB.NET um später vermutlich in einem Team zu sein, welches hauptsächlich Webentwicklung macht. Sprich du kannst danach gleich mal C# lernen. Vor allem warum macht man in der Firma VB UND C# o.O Für mich hört es sich gerade so an, als ob man dich in .NET einarbeiten will und du dich erstmal um alte VB Projekte kümmern darfst.

Ok vergiss was ich gesagt habe, ich war mir 100%zig sicher, dass man die Zuordnung von Click dann in der .Designer.vb sieht, aber da ist nix....hab ich wohl falsch in Erinnerung. Jedenfalls finde ichs gerade nicht in meinem Test. Nvm in c# finde ichs this.button1.Location = new System.Drawing.Point(559, 213); this.button1.Name = "button1"; this.button1.Size = new System.Drawing.Size(75, 23); this.button1.TabIndex = 0; this.button1.Text = "button1"; this.button1.UseVisualStyleBackColor = true; this.button1.Click += new System.EventHandler(this.button1_Click); aber nicht in VB...bin VB-blind

Und das ist eben das Problem am Designer, da sieht man das ganze Zeug einfach nicht. @DieMstar schau dir mal die Designer Datei an, da wirst du sehen, dass du deiner Oberfläche auf diese Art und Weise oft ein Event hinzufügst....nur...der Designer macht dies halt für dich schon.

Um es extrem simpel zu sagen: Delegaten sind ähnlich die Funktionszeiger (wie die Docs ja schon sagen). Sie können auf Methoden eines Objects, statischen Methoden oder anonymen Methoden verweisen. Du kannst auch dem Delegate ganze Objekte übergeben. Mir persönlich hat https://buildplease.com/pages/why-delegates/ gut geholfen zu verstehen, wie sie in der Praxis eingesetzt werden können. Du kannst halt in nem Delegate mehrere Sachen "abwickeln" und sparst dir so manchen Code immer wieder zu schreiben. Siehst du schön in den letzten zwei Codebeispielen auf der Seite.

Macht auch voll Sinn ohne jegliches Wissen über .NET einfach mal so in die Tasten zu hauen. Werden ihre zukünftigen Kollegen sicher mögen, was sie sich da aneignet /ironieoff. Kann sie monatelang an ein privates Projekt arbeiten nur um dann in der Arbeit zu sehen, was sie alles missverstanden hat.

Ich finde am besten kann sowas immer noch die offizielle Doc erklären. In dem Fall für VB.NET welches du ja verwendest: https://docs.microsoft.com/de-de/dotnet/visual-basic/programming-guide/language-features/delegates/

Wenn du mit Java angefangen hast, dann würde ich erstmal den ".NET Guide" und dann den ".NET Framework-Leitfaden" durchgehen: https://docs.microsoft.com/de-de/dotnet/welcome Dadurch lernst du viel unabhängig von der .NET Sprache die du anwendest. Anschließend solltest du den "Win-Forms"-Leitfaden nehmen. Direkt anzufangen ist gut und schön, aber du solltest schon etwas rund um .NET wissen. Da du nicht ".NET-Core" verwendest, aufpassen dass du nicht in den Tutorials ".NET Core" und ".NET-Framework" vermischt.

Ich weiß zwar wenig von VB (mag es überhaupt nicht), aber bist du sicher, dass ihr im Unternehmen was Datenbanken angeht nicht das Entity Framework einsetzt?

Was genau ist jetzt die Frage? Wie du ne Authentifizierung einreichtest? Wie du in einem Projekt mit der Datenbank arbeitest? Wenn ja, arbeitest du mit dem EF?

Zwischen einem normalen Startup und einem Startup das von einem Großunternehmen o. Konzern gegründet wurde gibt es doch noch ein paar Unterschiede. Siehst du ja auch am Gehalt, dass dir angeboten wurde.

Wesentlich wichtiger ist der Inhalt und wie verständlich DU diesen Inhalt überbringst, sowie ein logischer Aufbau...alles weitere findest du in der Bewertungsmatrix deiner IHK (viele haben diese veröffentlicht.) Wenn da was schlecht ist, kannst du es glaube ich kaum mit ein paar Animationen wegmachen. Nice 2 have...aber ich würde mich wundern wenns dafür groß "Bonuspunkte" geben würde. Edit: deine Animationen oben finde ich persönlich ziemlich anstrengend.

Du weißt nicht wie X geht. Du googelst nach "Wie geht x StackOverFlow". Du bekommst mit etwas Glück gleich mal 10 Threads mit je 5+ Antworten....viel Spaß eine zu suchen die vielversprechend und up2Date ist Vor allem muss man erkennen können, ob es ne gute Lösung ist, oder ne Notlösung bzw. ob es "hacky" ist (ist ja schlecht wenn du sowas einbaust, was in der nächsten .NET Version dann nicht mehr geht). Die Lösungen kann man meist eh nicht übernehmen, aber man kann sehen wie andere etwas gelöst haben und ob man diese Vorgehensweise nutzen kann.