Laden...
M
Benutzerbeschreibung
-VS Code, VS 2019 Comm.

Forenbeiträge von M.L. Ingesamt 374 Beiträge

04.06.2024 - 11:36 Uhr

großer Brocken

Zwecks Erleichterung: der C#-Compiler erwartet 'nur' gewisse formelle Anforderungen an den Code. Schlagwörter wie "MVVM" oder "Reactive Extensions" beschreiben wie man häufige(re) Änderungen oder Erweiterungen (Darstellung von UI-Elementen, Live-Daten,...) i.Z. mit WPF implementieren sollte (i.S. von geschicktem Auslagern im Quellcode oder auf andere Threads).

18.05.2024 - 07:33 Uhr

Berufsschule

(etwa offtopic) jetzt könnte die Gefahr bestehen, dass weitere Codier-Methoden gelehrt werden, die früher durchaus Sinn hatten.  Und das Aufgaben mit Mitteln von früher bearbeitet werden wollen  (und dann auf modern(er)e Ratschläge trifft)

17.05.2024 - 10:09 Uhr

"Spaghetticode"?

Es gibt noch mehr Möglichkeiten aus menschlicher Sicht schwer(er) lesbaren oder erweiterbaren Code zu schreiben, weitere 25 (Codier-)Empfehlungen werden hier aufgeführt (gilt für Java, unter C# sieht die Sache aber ähnlich aus) : https://www.javaguides.net/2024/05/25-best-practices-for-java-developers.html

Im Grund gilt es die Teile der Software mit geringem Änderungsgrad (möglichst geschickt) zusammenzufügen und die Teile mit (sehr) hohem Änderungsgrad (möglichst geschickt) auszulagern.  Aber ab einer gewissen Komplexität dürften selbst Spezialisten-Teams ein Problem mit der implementierten Software haben.

16.05.2024 - 08:26 Uhr

In der Dokumentation recherchieren (oder KI befragen) gehört auch zur SW-Entwicklung...

Hier könnten Befehle wie "DateTime jetzt = DateTime.Now; "   "DateTime zukunft = jetzt.AddSeconds( /*Ganzzahl */ ); "  "while (DateTime.Now < zukunft) ..."  weiterhelfen

15.05.2024 - 15:48 Uhr

Neuling im Programmieren.

Generell geht es beim Programmieren um die Frage wie sich der Compiler (Interpreter / Transpiler / ...) verhält, wenn er auf ein bestimmtes Schlüsselwort (evtl. i.V. mit anderen Schlüsselwörtern) (nicht) trifft.   Der C#-Compiler gibt auch Leitplanken an formell korrekten Code vor (neuere Compiler-Versionen sind hier aber liberaler). Und aus menschlicher Sicht ist der Code so zu schreiben, dass häufige(re) Änderungen oder Erweiterungen nur an einer zentralen Stelle vorzunehmen sind.

11.05.2024 - 08:25 Uhr

in C# nicht geübt!)

Kurz: der verwendete C#-Compiler hat mehr Leitplanken an formell korrekten Code, zum Beispiel die Verwendung von Klassen zur Strukturierung des Codes  (neuere Versionen sind hier liberaler, aber der Compiler fügt die passenden Schlüsselwörter im Hintergrund hinzu).  Vermutlich wurde das Original VB .NET Programm eher prozedural implementiert.

25.03.2024 - 10:39 Uhr

Auch hallo

Solche Anfragen könnte man an eine KI ( Bing CoPilot, Devin, ChatGPT,...) auslagern (<- die Anfragen wollen aber genauso gut formuliert werden wie in der analogen Welt, und wie der Compiler auf ein (oder mehrere) Schlüsselwort(e) reagiert will trotzdem verstanden werden. KI-Ergebnisse beachten menschliche Prioritäten wie Lesbarkeit, Änderungen, Erweiterungen, Testbarkeit, ...  nicht (zumindest nicht standardmässig) )

Zwecks Erfolgserlebnis ein kurzer Ausschnitt (auch zum Verbessern / Erweitern ...) aus dem Vorschlag von Bing CoPilot:

 ...for (int i = number - 5; i <= number + 5; i++)
{
   Console.WriteLine(i);
}...
19.03.2024 - 07:24 Uhr

Evtl. findet sich die Antwort in den eingebundenen Namespaces "Ion.sdk. ..." oder "autofac".

11.02.2024 - 06:53 Uhr

Zitat von TiltSchweiger

...einfach mit aufgezählt werden ...

...

            ofstream fout("kartenverkauf.txt", ios::app); // an Textdatei anhängen

           ...
        -->  Zusätzlich *könnte* das beschriebene Verhalten am (Nicht)Benutzen der passenden Parameter liegen (append-Modus): https://cplusplus.com/doc/tutorial/files/ 
05.01.2024 - 11:01 Uhr

Zitat von wmolle

2009

Hier ein Beispiel für eine Wiedereinarbeitung nach rund 10 Jahren Abstinenz in .NET: (youtube, "thenativeweb", "Golo macht wieder .NET ?!")  https://www.youtube.com/watch?v=rPLyJgnyMHU

04.01.2024 - 09:25 Uhr

(etwas offtopic) "Hauptsache läuft" führt (irgendwann) zu schwer lesbarem / änderbarem / wartbarem ... Code. Zwecks höherer Robustheit und oder erleichtertem Ändern oder Erweitern gibt es Stichworte wie "SOLID", "Namensgebung", "Schichtentrennung", "Software-Tests", "x-Architektur", ...

Von Hanser gibt es mehrere Bücher zum Thema "C# und .NET". Was der verwendete C#-Compiler als formell korrekten Code anerkennt, hängt auch teilweise von der verwendeten .NET-Runtime ab (wobei im Lauf der Zeit andere Wege von der Idee zum Programmier-Ziel dazugekommen oder nicht mehr empfehlenswert sind)

11.12.2023 - 09:40 Uhr

Zitat von StayCalm

C- ... C#

--> im Endeffekt gibt C# mehr Leitplanken vor als C ( Stichwort "unsafe code" ).  Den Code derart gestalten, dass (häufige(re)) Änderungen oder Erweiterungen (an zentraler Stelle) leicht(er) vorgenommen werden können, soll(te) man aber überall beachten.

11.11.2023 - 07:13 Uhr

Als Werkzeuge kommen wohl Visual Studio und VS Code zum Einsatz ?

Zum Erweitern / Ändern / ... dürften wohl bekannte Schlagwörter zum Zug kommen: sprechende Namensgebung, Schichtentrennung, Auslagern von Teilen mit hoher Veränderungsrate, SW-Tests, SOLID-Prinzipien,...

24.10.2023 - 09:41 Uhr

Bzgl. alternativer Engines mit C# einige Vorschläge von Google Bard: Stride, Godot, CryEngine (€), Monogame , OpenTK

23.10.2023 - 17:13 Uhr

Die vorige De-Installation (via Visual Studio Installer ?) könnte störende Reste hinterlassen haben.

(off-topic) was Unity angeht, könnten (langfristig höhere) Gebühren aufkommen:  https://www.heise.de/news/Kompromiss-von-Unity-Aeltere-Spiele-werden-von-Runtime-Gebuehr-ausgenommen-9314697.html

13.10.2023 - 08:04 Uhr

Das ist mehr im SQL-Bereich zu suchen, im konkreten Fall filtern die WHERE- und/oder LIKE-Klausel (S. 512ff (Kap. 8.4.3ff) des Buchs "Einstieg in C# 2022 mit Visual Studio" aus dem Unterforum "Buchempfehlungen")

Zwecks Vorabhinweis (geht aus dem Buch nicht hervor): bei Daten verändernden Operationen verwendet man Parameter  (-> https://mycsharp.de/forum/threads/66704/artikelserie-sql-parameter-von-befehlen) und bei GUI-Programmierung MVVM und Drei-Schichten-Architektur (-> https://mycsharp.de/forum/threads/118261/artikel-mvvm-und-databinding  //  https://mycsharp.de/forum/threads/111860/artikel-drei-schichten-architektur )    Der längerfristige Vorteil besteht in der höheren Sicherheit des Programmablaufs und man kann -auf menschlicher Seite- (häufige(re)) Änderungen oder Erweiterungen leicht(er) vornehmen.

Für weitere Connection-Strings (inkl. Parameter):  https://www.connectionstrings.com/

11.10.2023 - 14:22 Uhr

"Schrödinger programmiert C#" wird Anforderungen wie WPF, DB-Anbindung wohl eher nicht erfüllen: https://www.rheinwerk-verlag.de/schroedinger-programmiert-c-sharp/  → Komplettes Inhaltsverzeichnis

05.10.2023 - 12:12 Uhr

"..zu hoch.."  --> grundsätzlich ist in der SW-Entwicklung von einem häufig(er)en Ändern oder Erweitern einer Software -im Idealfall- an einer (zentralen) Stelle auszugehen. Am Beispiel des Links zu csharpcorner: wenn es Änderungen an den Daten gibt (...ID=3,Name=”Arvind”..., ID=5,Name="Weihnachtsmann",...) gilt es diese nur an einer Stelle vorzunehmen. Oder die Datenquelle ändert sich zu einem anderen DB-System → DataBinding

Weitere Stichworte die das Ändern oder Erweitern aus menschlicher Sicht erleichtern: Schichtentrennung, sprechende Namensgebung, Namespaces, SW-Tests, Versionskontrolle,...

05.10.2023 - 07:54 Uhr

Auch hallo,

i.Z. mit ASP.NET könnte das hier helfen: https://learn.microsoft.com/de-de/aspnet/web-forms/overview/ajax-control-toolkit/combobox/how-do-i-use-the-combobox-control-cs    Und was verändernde Datenbankoperationen angeht: [Artikelserie] - SQL...

19.09.2023 - 13:49 Uhr

Als Schlagwörter könnte man auch zu "Macroservices" oder "Modulithen" recherchieren (ändert aber wohl nichts Fundamentales an den vorigen Postings)

28.08.2023 - 12:10 Uhr

Zitat von Rayano

Geld knapp

Auf der geposteten Seite ganz runterscrollen und die kostenlosen Blog-Artikel zu z.B. C#, Python,... durchlesen und -bearbeiten (irgendwann könnten die Anbieter schon Geld sehen wollen...)     Längerfristig ist ein (häufigeres) Ändern und oder Erweitern der Software einzuplanen, was Stichworte wie z.B. "Design Patterns", "Datenstrukturen" oder "SOLID" erklärt

28.08.2023 - 07:44 Uhr

IronPython ( https://de.m.wikipedia.org/wiki/IronPython ) könnte man sich auch ansehen.

24.08.2023 - 07:46 Uhr

Vereinfacht fügt man die wenig(er) veränderlichen Teile einer Software zusammen und lagert die stärker veränderlichen Teile geschickt aus. Wobei es aber auch auf den Ziel-Kontext ankommt, welche Teile welchem (feingranularen) Änderungs- oder Erweiterungsgrad unterliegen.

Schlagwörter wie "SOLID-Prinzipien" (*), "DDD", "Namensgebung", "TDD", "KISS", "Namespaces",...  dienen dem Menschen als Empfehlungen (nicht als Gesetz) um das (häufige) Ändern / Erweitern / Warten /..  der Software zu erleichtern (<- ab einer gewissen Komplexität dürfte aber selbst ein (grösseres) Spezialisten-Team damit ein Problem haben)

(*)das Auslagern in Klassen könnte langfristig gegen das I und D verstossen

21.08.2023 - 09:47 Uhr

Man könnte es mit https://playwright.dev/dotnet/docs/intro versuchen.  Serverseitig könnten aber Schutzmechanismen  aktiv sein um ((zu) häufige) Abfragen (z.B. einer wiederkehrenden URL oder unauthorisierter Nutzer)  zu verhindern.

21.08.2023 - 09:12 Uhr

Neben virtuellen Maschinen könnte man sich Docker ansehen: https://hub.docker.com/_/microsoft-dotnet-runtime

31.07.2023 - 09:29 Uhr

Zitat von cprogrammer

welche man der Methode bei ihrem Aufruf übergibt, die in der Klasse, welcher der Methode angehört, nicht vereinbart ist,

aber für die Berechnung erforderlich ist.

--> externe (und damit -tendenziell- nicht testbare) Abhängigkeiten könn(t)en auch langfristig Probleme machen und in schwer lesbarem (und schwer bis gar nicht überarbeitbarem) Code enden.

29.07.2023 - 09:24 Uhr

Generell gibt C# mehr Leitplanken vor (im Ggs. zu z.B. C / C++ ). Zeigeroperationen fallen unter "unsafe code":  https://learn.microsoft.com/de-de/dotnet/csharp/language-reference/unsafe-code

02.07.2023 - 18:17 Uhr

Mit einem virtuellen Ubuntu 22.04 scheinen die Anleitungen (auch ohne VS Code) zu funktionieren (Screenshot im Anhang, wenn auch ohne tiefgehenden Test)

02.07.2023 - 08:54 Uhr

Auch hallo,

unter Ubuntu 20 könnten die Hebel wohl woanders (neben Lese- und Schreibrechten) liegen:  https://learn.microsoft.com/en-us/dotnet/core/tools/enable-tab-autocomplete   (Quelle: https://learn.microsoft.com/en-us/dotnet/core/install/linux-ubuntu-2004 )

18.04.2023 - 12:05 Uhr

Zitat von Runenmeister

Parameter und Eigenschaften

--> Das kann evtl. (auch) sein, vgl. mit https://www.dotnetperls.com/richtextbox  (Abschnitt zu rtf: "(..)RTF stands for Rich Text Format, and this describes a certain file type where text formatting is encoded with special characters embedded in the text.

Tip When you apply formatting in a RichTextBox, you can access the richTextBox1.Rtf property to get the encoded RTF data.(..)"

25.03.2023 - 09:56 Uhr

Evtl. könnte der Hosting-Anbieter auch Docker anbieten, welches man mit ASP.NET Core verbinden könnte: Tutorial bei learn.microsoft.com

22.03.2023 - 09:45 Uhr

steilen Weg

Um die Wegfindung zu erleichtern: HTML ist eine Seitenbeschreibungssprache, CSS ist für die optische Darstellung im -jeweiligen- Browser sichtbarer HTML-Elemente zuständig. Im Gegensatz zu C# kennt HTML syntaktische Möglichkeiten wie Klassen, Schleifen, Annotationen,... nicht: MS Learn - "ASP.NET MVC 4 – Hilfsprogramme, Formulare und Überprüfung" ( nur (cs)html-Code beachten: alles mit @ am Anfang wird ein Browser syntaktisch nicht verstehen )

17.03.2023 - 20:36 Uhr

Was CSS betrifft: Cascading Style Sheets (wobei CSS auch Vererbung (engl. "inheritance") verwendet )
Eine Aufteilung des Webprojekts in separate html und css-Dateien kann auch hier Sinn haben um Änderungen/Erweiterungen leichter umsetzen zu können. Und bei komplexeren Seiten erst die Controls zeichnen lassen, danach in der gewünschten Formatierung (die css-Befehle also am Ende der Datei platzieren oder importieren lassen)

10.03.2023 - 17:13 Uhr

Weitere Vorschläge (wenn auch nicht C#-nativ): Link bei DataScienceDojo

28.02.2023 - 20:59 Uhr

Begriffe wie (z.B.) "top-Level" oder "main" gibt es in Python auch, aber diese haben dort eine andere Bedeutung: Beitrag bei RealPython

26.02.2023 - 08:34 Uhr

Im Vergleich zum Python-Interpreter achtet der C#-Compiler stärker auf syntaktische Formalien (im Sinn von (immer (*)) zu schreibendem Code), "code intendation" ist egal.

Im Minimalfall: -alle definierten Variablen, Methoden,... sind zwingend Bestandteil wenigstens einer Klasse, -"static void Main(string[] args)"-Methode in der ausführenden Datei, -Datentypsicherheit ist strikt einzuhalten (implizite oder explizite Typkonvertierung gibt es auch hier)

(*)neuere .NET Versionen verlagern solche Aktivitäten mehr in den Hintergrund, Bspl. "altes" Hallo Welt vs. "neues" Hallo Welt:

namespace HelloWorld
{
    class Hello {         
        static void Main(string[] args)
        {
            Console.WriteLine("Hello World!");
        }
    }
}  

(neu)

 Console.WriteLine("Hello World!"); 

Konzepte wie Namespaces, Coding Guidelines, Aufteilung in Schichten, TDD, Dokumentation, Architektur,... dienen aus menschlicher Sicht dem einfach(er)en Lesen/Schreiben/Ändern/Erweitern/... des Codes (auch in Python)

13.02.2023 - 07:44 Uhr

Zum Thema "Web API" (von der Eigenwerbung mal abgesehen) siehe den aktuellen Newsletter von entwickler.de

12.02.2023 - 22:02 Uhr

Qt, Dafür gibt es einen Online Installer bei [url= Download Qt: Get Qt Online Installer] qt.io[/url]

09.02.2023 - 08:39 Uhr

Klassen in C# sind die falsche Wahl...OOP

Generell: der C#-Compiler erzwingt die Verwendung von (wenigstens einer) Klasse(n) um Methoden/Variablen/... dort zu definieren. Zwecks OOP (neben dem Openbook) siehe diesen
Twitter Thread
Der längerfristige Sinn dieser (strenggenommen nur empfohlenen) menschlichen Verhaltensweisen wird klar, wenn man die Software (an zentraler Stelle) häufig(er) (oder leicht(er)) ändern/erweitern/nutzen/... will: Entwurfsmuster, Schichtentrennung, SOLID-Prinzipien, OOA, OOD, TDD, K.I.S.S., Namensgebung, ...

03.02.2023 - 14:54 Uhr

Ein Server ist im Kern ein Programm, welches auf Eingaben von aussen wartet und (irgendwelche) Resultate nach aussen zurückliefert. Node.js scheint (neben Apache + PHP) wohl auch nutzbar zu sein: (etwas älteres Video) https://www.youtube.com/watch?v=tkbu3TT5LT8

22.01.2023 - 10:28 Uhr

im geschützten Speicher zu lesen oder zu schreiben

Funktioniert der ursprüngliche C/C-Code wie angedacht ? Wobei ein C oder C - Compiler (zumindest zur Kompilierzeit) idR ein liberaleres Verhältnis zum Manipulieren von Speicherinhalten hat.

21.01.2023 - 13:34 Uhr

Es könnte z.B. gefragt werden, ob es einen codetechnischen Unterschied zwischen einer 1..0* und 0..1 Assoziation gibt. Dieser Artikel könnte weiterhelfen: https://www.codeproject.com/Tips/596709/Implementation-of-Type-of-Association

20.01.2023 - 10:04 Uhr

Die Verwendung von LPSTR deutet übrigens auf einen (sehr) alten C++-Code hin: difference-between-char-and-lpstr-in-windows

18.01.2023 - 08:49 Uhr

auf irgendeine Weise funktioniert es

  
...Person2.Text, txtin_Person3.Text, txtin_Person4.Text,...  
                        txtin_Person4.Text...   
                        txtin_Person5.Text   

Längerfristig sollte man (häufige(re)) Änderungen/Erweiterungen/Wartbarkeit/... des Codes einplanen (deswegen auch die bereits genannte Schichtentrennung: um genau diese Aktionen (an einer (zentralen) Stelle) zu erleichtern). Um mehrere Controls anzusprechen gibt es auch einen Artikel: FAQ - Variablennmen zur Laufzeit...

17.01.2023 - 14:07 Uhr

Prinzipiell geht so etwas, Stichwort z.B. "Web Scraping"
Es kann aber (z.B.) sein das die Zielseite Schutzmechanismen gegen zuviele Anfragen (pro Zeiteinheit) aktiviert hat oder Hintergrundinformationen geliefert werden wollen (die nur ein richtiger Browser mitgibt)

14.01.2023 - 17:33 Uhr

WPF .. Neuling Zwecks Erfolgserlebnis könnte man hier schauen: https://www.dotnetperls.com/webbrowser-wpf

14.01.2023 - 10:34 Uhr

Abhängigkeit... "gutem" Code Man sollte -auch auf Vorrat- davon ausgehen, dass sich die externen wie internen Laufzeitbedingungen eines Programms (öfter(s)) ändern können (z.B. könnte man das Vorhandensein einer Registry oder bestimmter Äste dort im Vorab abfragen). Ansonsten besteht eine weitere Gefahr von "Pain Driven Development" (Anspielung auf das neuste YT-Video von D. Tielke)