@ WinSharp93: Das ist es gewesen 👍
das ist aber krank

aus der Quelle:

This is effectively my brainteaser #1 😁

@FZelle: Doch, doch da ist eine Vererbung ingange. Den Unterschied zwischen Verbergung und Überschreibung ist mir dagegen geläufig, etwas zumindest.

Hallo,

ich übe mich gerade an Vererbung und Überladungen ein.
Um es kurz zu machen:

Wenn der Methoden-Parameter bei den Eltern im Wertebereich kleiner ist als bei den Kindern, werden IMMER die Kinder-Methoden aufgerufen, unabhängig von Casting;d.h.int = short = byte und float = double = char (!)

Würde man die Parameter tauschen funktioniert es wie erwartet.

Die IDE zeigt die Auswahl an Überladungen übrigens komplett an.

class Parent
    {
        public void Overload(char c)
        {
            Console.WriteLine("Typ Char");
        }
    }
    class Children : Parent
    {
        public void Overload(double d)
        {
            Console.WriteLine("Typ Double");
        }
    }

    class Program
    {
        static void Main()
        {
            Children kindVar = new Children();
            char meinChar = 'a';
           Console.WriteLine("Typ {0}", meinChar.GetType());
          kindVar.Overload(meinChar);                  // Typ angeblich Double
          kindVar.Overload((char) 'a');                  // -"-
          kindVar.Overload(Convert.ToChar('A'));     // -"-
            Console.ReadLine();
        }
    }

Ist das ein Fehler oder versteh ich einfach irgendwas nicht; normalerweise müsste im Beispiel das Eltern-Objekt aufgerufen werden, weil der Typ byte ist...

etwas spät... aber

vielen Dank! 👍

Hallo chilic,

naja die ersten Suchen können längern dauern, da es in meinem Fall eh in den RAM gecacht wird. Tatsächlich sind schon alle Daten darin enthalten.
Das mit dem String ist ein guter Tipp, danke.

Hmm ich arbeite mich an einer C++ Express ein und probiere es erstmal auf simples Text-Auslesen, wie die Skriptvariante. Ich denke dass dürfte schneller sein als Linq etc. da sämtlicher Overhead und Kontrollen entfallen...

Hallo,

in einem Projekt möchte ich die kompletten Pfade aller Dateien (255 Zeichen max.) eines Rechners sowie zu jedem Pfad etwa dazugehörige 20 0/1-Attribute bzw. einen weiteren, 20 Zeichen langen String vermerken.
Wie erreiche ich die höchstmöglichste Perfomance für das Suchen eines bestimmten Pfades bzw. Rückgabewerte von mehreren Tausend Datensätzen? Mit einer ASP Datenbank? Oder mit Textdateien? Oder alles in einem Cache?

Zielsetzung ist es z.B. bei 1 Mio Datensätze die Wartezeit z.B. auf z.B. E6600 2,4Ghz unter 3sek - möglichst aber zeitgleich - beträgt und der RAM-Verbrauch gleichzeitg möglichst niedrig ist (pi mal daumen 100 MB pro Millionen Datensätz)?

Die momentane Skriptlösung braucht für 720.000 Datensätze erstmalig 55sek, später 26sek (nur ein CPU-Kern @ E6600) und benötigt 50 MB an RAM bzw. für die Datensätze.

Guten Morgen,

während ich mir ein Flash-Video anschaue, lädt der Browser es in den Cache unter einem temporärem Namen,
Ich wollte nun ein Skript schreiben, welches mir die Datei rauskopiert, sobald sich die Größe nicht mehr ändert, also die Datei fertig geladen ist:

using System;
using System.IO;
using System.Threading;

class MeinProgramm
{
    public static void Main()
    {
        long test1, test2;
        FileInfo tempi = new FileInfo(@"d:\temp\opera\flashtemp");
        do
        {
            test1 = tempi.Length;
            Console.WriteLine("{0} {1}", tempi.Name, tempi.Length);
            Thread.Sleep(3000);
            tempi.Refresh();
            test2 = tempi.Length;
            Console.Clear();
        } while (test1 == test2);
        File.Move(@"d:\temp\opera\flashtemp", @"d:\temp\woanders");
    }
}

Dumm nur, dass es funktioniert, wenn ich selber z.B. eine Text-Datei editiere, aber wenn der Browser die Datei cacht, gibt es einen Laufzeitfehler von C#, die Datei würde von einem anderen Prozess verwendet werden. Welchen Lösungsansatz gibt es?

Hmm, bis 50 bis max. 150 Euro wär ich ja noch gegangen, das Zend Studio kostet aber über 900 Euro... und ist für mich als semiprofessioneller User da nicht drin. Aber sollte ich damit richtig lange arbeiten, weiß ich wo ich suchen muss 😄

@ Corpsegrinder:
Die 19.x muss man selbst kompilieren. Aber ich habe eine Lösung im rubyforum gefunden. Das erste Kompilat ging auch schief, aber ich versuchs nun mit einem zweiten Programm.

@ Xynratron:
Da irrst du dich. Ich beschäftige mich seit ca. 3-4 Jahren mit der .NET Materie (genauer seit Version 1.1), meist auf theoretischer Ebene. Wäre VB6 wirklich dem VB.NET ähnlich, wo hätte ich VB.NET erlernt. Aber wie du siehst habe ich mich für C# entschieden. Nur die Microsoft eigenen Lernbücher sagen, dass diese zwei VB Sprachen sehr ähnlich sind.
Aber ASP schau ich mir davor genauer an; der Name klingt schon an sich soo kompliziert 😉

@ LaTino:
Danke für die Aufklärung... Mal sehen wie sich es so entwickelt...

Pff soviele Fehler in nur 2 meiner Beiträgen 😭

So ist z.B. die Version 1.9.1 - die erste stabile und freigegebene 1.9 Version - natürlich erst Anfang diesen Februar und nicht Oktober geboren.
Nach etwas Recherche erscheint mir Python die bessere Sprache für Windows-Anwendungen und Ruby für Webanwendungen. Aber viel nehmen sich beide nicht.

@ Corpsegrinder:
Ich möchte mir das Umlernen sparen und schiebe anderen Stoff - XML, Javascript und CSS - in die Lücke. Deswegen erst mit den ersten 1.9.1 Tutorials loslegen und ROR müsste dann auch schon angepasst dafür geben. Nur zeigt Amazon, dass es weit und breit keine geplanten Bücher dafür in Mache sind -.-
Zudem bekomme ich 1.9.1 einfach nicht installiert (muss man mit cygwin oder C compilen machen).

@ onlinegurke:
ASP.NET ist eine Technologie? Ja stimmt, der Vergleich war nicht fair. Statt in ASP.NET muss man sich bei Ruby halt in ROR einarbeiten. Dafür ist dort wiederum SQL gleich inklusive. Aber HTML+CSS sind für alle Webapplikationen ein Have-To. HTML hat man im Grunde schon nach 2 Wochen ziemlich gut drauf.

@ MDCoke:
In Ruby kann man C Bibliotheken einklinken, was im Grunde die gleiche Möglichkeit erfüllt, betriebsinternen Code bzw. perfomanten Code zu schreiben.
VB.Net ist schon erheblich an C# angelehnt und hat mit dem alten VB6 (fast) gar nichts mehr zu tun, auf bis das die Schlüsselwörter und einige Konventionen übernommen worden sind. Mit dem typensicher ist wohl wie vielfach erwähnt eine Geschmacksfrage.

Verdammt, bis auf das fehlende OpenSource Modell Laut wiki hat es mehrere Nachteile in der Sprachkonstruktion gegenüber Ruby sollte ich mir Python zumindest mal einen Blick rüberwerfen...

Recht herzlichen Dank

Einen schönen Wochenendanfang an alle 🙂

@ kubi: Das mit IronRuby ist ja bloß wieder eine Nachahmung für das ROR Framework wie prado, phpCake usw. Klar hat die .NET Implentation Vorteile wie nativen WinVista / Win7 Support, Verwendung mehrerer .NET Sprachen und die vielbetonte Geschwindigkeit... Aber eine Kopie kommt in der Einfachheit wohl nicht im Original und hat immer zusätzliche Workarounds hmmm

@ Peter Bucher: ASP.NET bzw. Derivate habe ich mir nicht angeguckt. Klingt mir aber in der Realisierung viel komplexer als das ROR Framework. Lieber ein zusammengehöriges Paket mit gleicher Sprache als ein zusammengebasteltes mit 2 verschiedenen Sprachen, gell? Wobei ASP.NET natürlich viel Gemeinsamkeiten mit C# hat.

@ Corpsegrinder: Du hast Recht, der Anwendungszweck bestimmt letzenendlich die Mittel, also die Sprache. Ruby ist - wie du meintest - in geschwindigkeitskritischen Szenarien (Industrieprozesse, Spiele, HighspeedDatenbank), Embbed Systeme und Treiberprogrammierung nahezu total ungeeignet.

Aber im "Mainstream" - Programmentwicklung und noch mit einem echt starken Bonus für zukunftsträchtige Webapplikationen in Form eines harmonierenden Web-Frameworkes, ist Ruby wohl eine starke Alternative.

@ LaTino: Und was ist der Grund für das vernachlässigende Design? Aber da Ruby ausgelegt ist, das DRY-Prinzip beharrlich anzuwenden (eigentlich gültig für jede OO Anwendung), sollte ein Redesign relativ einfach zu beheben sein? Das mit sexy, ja da kann ich dir aus eigener Erfahrung Recht geben 👅

@ Xynratron: Das "man muss es halt können" ist ja gerade das Problem bei ASP.NET. Bei Ruby kann man viel früher Ergebnisse bei anschließender ähnlicher Entwicklungszeit erreichen afaik. Man spricht sogar von 10% Java-Code bzw. 50% PHP Code Einsparung. Wohl eher eine Sache des Programmierers, aber Ruby sollte da auch einen Anteil haben. Mit der Datenbank seh ich es ähnlich wie bei ASP.NET, dass die Einbearbeitungszeit wohl zu lang ist.
Klar, als Open Source Sprache / Framework kann Ruby interne Programmierfehler ausbügeln, das wäre noch ein Vorteil für Ruby. Aber sehr theoretisch, da nur für Experten.
Die Syntax finden, wenn man sich umsurft, ebenfalls runde 90% viel angenehmer als PHP und z.T. sogar als C#. Ich fand die 20min Demo auf deren Homepage sehr gelungen und intelligent. Ich hab eine einzige negative Kritik dazu gelesen, wobei an der handfeste Beweise fehlten (ohne Code Beispiele).

Ich habe heute jedenfalls einen Kurzvortrag gehalten und habe zum ersten Mal im Leben echte Anfragen bekommen, dass man sich mehr für Ruby interessiert und wo man weiter forschen soll usw.
Ich selber werde wohl die Finger von Ruby lassen, da zwischen 1.8.7. und 1.9.1 (Anfang Oktober) erhebliche Unterschiede geben soll und ich erst mit den ersten Dokumentationen zur neuen Sprachversion einsteigen und nicht schon wieder umlernen möchte. Vielleicht habe ich aber auch so einen bleibenden Eindruck gegeben, dass selbst die Lehrer sich entscheiden, darauf umzuschwenken.

Ihr seht mir schon die rosarote Brille an, ich weiß 😉, aber eine Frage hätte ich da noch:

Auf der anderen Hand; wenn Ruby wirklich so gut sein sollte, wie 90% der Internetkriterien bescheinigen, frage ich mich, warum nicht mehr Leute mit Ruby programmieren bzw. die Entwicklung leicht stagniert (TIOBE Index 11, 3,x % )?

EDIT: Ich entschuldige mich, falls es so rübergekommen ist, wie es mir gerade vorkam, als ob meine Aussagen allein-allgemeingültig sind. Idz alles natürlich nur mein Feedback...

Yoah, das ist schon ein wichtiger Unterschied...
Nachdem ich mich näher mit PHP beschäftigt habe, habe ich einen Umschwung zu Ruby gesehen, aber das ist hier ja Off-Topic und in einem anderen Thread von Bedeutung.

Danke & Gruß

Guten Abend,

ich hab ein bisschen gegoogelt danach, aber so richtig Handfestes nicht gefunden.
Obwohl ich starker C#-Sympathiast bin, scheint mir Ruby nach einer Woche Recherche irgendwie die "bessere" Sprache zu sein vom P/L Verhältnis:

Auf der HABEN-Seite

• sie hat eine einfachere Syntax allgemein
• mit Ruby On Rails Framework kann man mal soeben ein doch ansprechende Website in wenigen Tagen kreiern (klar HTML+CSS beherrscht man ja)
• die Integration der Datenbank via SQL ist sehr eng (bei C# mehr Lernaufwand durch LINQ)
• kann mir aussuchen ob objekt-orientiert oder prozedural oder funktionell programmiert wird
• effizientes Konvention ersetzt Konfiguration Prinzip (bezieht Dateinamen und Verzeichnishierachiern mit ein)
• Von Haus aus sicher konfiguriert für Webanwendungen

Auf der GLEICH-Seite

• plattformunabhängig
• Garbage Collector
• Inkompatibilitäten zu früheren Versionen

Auf der VERLIERER-Seite

• Interpreter --> langsamer
• Win GUI-Anwendungen sind nicht so leicht zu erstellen wie mit VC# Express
• evtl. GUI (aber es gibt ja Eclipse =)

Irgendwie überzeugt mich Ruby einfach mehr. Die heutigen Computer sind schon so schnell, dass die Ausführ-Geschwindigkeit von Büroapplikationen ja zu vernachlässigen ist. Außerdem ist mit Ruby die Erstellung von Web Applikationen um ein vielfaches einfacher zu sein als mit C# + Zusatztechniken. Das sehe ich als wichtiger Vorteil gegenüber C# an, während C# selbst wohl keinen gleichwertigen Vorteil bietet? Als Webseitenprogrammierer bin ich wohl mit Ruby viel besser beraten als mit C# und habe noch eine Option auf Desktop-Anwendungen.

Bin gespannt auf eure Antworten 🤔

Hey, gibts ja doch noch eine kostenlose Variante 😄

DAnke für die zahlreichen Antworten.

Eclipse + Plugins hört sich sehr gut an!

PHP-Edit und auch das auf VS basierende PHP Plugin konnten mich beim schnellen Testen nicht überzeugen (kein Variablen merkennach OS-Neustart hat geklappt, etwas ungimpfliche Einrückungen, "featureärmeres" IntelliSense usw.).

Jetzt muss man sich aber wirklich einarbeiten in diese ganze Thematik!

Ich hab jetzt über 6 Stunden 10 verschiedene PHP-Editoren aller Größen ausgetestet; der beste PHP-Editor ist für mich der Komodo Edit 5 neben dem sehr großen Eclipse. Zwar ist die Austattung drumherum nicht wie von der besten der Klasse, aber der Editor als Kernkomponente überzeugt auf der ganzen Linie

Guten Morgen,

neben der vertrauten C# Express 2008 IDE, lerne ich nun auch PHP mit xampp. Als Editor verwende ich den Phase5 Editor. Jedoch vermisse ich viele Features, die mir zeigen, wie gut implementiert die C# IDE doch war... Kennt jemand PHP-Editoren nach dem Look & Feel von den Express IDEs? Also eine Art IntelliSense, Variablenprüfung, Kommentarshortcuts, Debuggerm automatische Einrückung usw. Die bisherigen Lösungen (UltraEdit, Weaversleave, PHPEdit) unterstützen dies alles irgendwie nicht?!

Gruß

Thema ist gelöst

Danke nochmal an alle!

/edit: @ ujr: Selbst mit c = -1 kommen die Zahlen dann immer noch gelegentlich doppelt oder gar dreifach, der Fehler steckt im Detail -.-

... das stimmt tatsächlich, wow!2

Wenn ich nur noch einen Ansatz finde, wie ich GMLOD "3. Schritt mit dem streiche den Wert dieses Eintrags aus der Liste", also Arrays löschen kann (ist ja was anderes als eine Nullzuweisung), ist auch dieses Thema wieder einmal zu meiner vollsten Zufriedenheit geregelt 😁

Habe bisweilen viel zu tun, so dass ich leider erst jetzt antworten kann:

@ GMLOD:

streiche den Wert dieses Eintrags aus der Liste

?
genau hier lag / liegt das Problem - ich weiß nicht wie ich das realisieren soll...

@ herbivore:

Sehr Interessanter Ansatz 😁

Hier gebe ich für Interessierte etwas Wissen zurück:

Hab zwischendurch eine 2. Lösungsansatz gefunden, der sich mit 12 Arrays begnügt (also ein gutes Fünftel), allerdings auch 6mal soviel vergleichen muss.

using System;

class Lottoglueck
{
    static void Main()
    {
        byte[] aktuellerTipp = new byte[6];
        byte[] vergleicheTipp = new byte[6];
        Random generator = new Random();
        for (byte b = 0; b < 6; b++)
        {
            aktuellerTipp[b] = (byte)generator.Next(1, 50);
            vergleicheTipp[b] = aktuellerTipp[b];
            for (byte c = 0; c < 6; c++)
            {
                if (aktuellerTipp[b] == vergleicheTipp[c] && b != c)
                {
                    aktuellerTipp[b] = (byte)generator.Next(1, 50);
                    c = 0;
                }
            }
        }
        Array.Sort(aktuellerTipp);
        foreach (byte b in aktuellerTipp)
            Console.Write(b + " ");
        Console.Write("SZ " + generator.Next(0, 10) + "\n");
        Console.ReadLine();
    }
}

Auffällig ist, dass Next() selbst nach einer Objektneuerschaffung (man kann ja das Objekt nicht löschen imho) ständig die gleichen Zahlen generiert, wenn man zwischendurch den Thread nicht anhält oder eine Benutzereingabe fordert. Es ist ganz leicht zu überprüfen, indem ihr die Main() Methode als 2. Methode unformuliert und diese mehrfach aufruft oder einfach ne Schleife drumherum bildet.

Hallo winsharp93,

deine erste Möglichkeit habe ich folgendermaßen umgesetzt:

using System;

class Lottoglueck
{
    static void Main()
    {
        byte[] aktuellerTipp = new byte [6];
        byte[] Tippzahlen = new byte[50];
        Random generator = new Random();
        Console.WriteLine("Lotto");
        for (byte b = 1; b < 50; b++)
            Tippzahlen[b]= b;
        for (byte b = 0; b < 6; b++)
        {
            do
                aktuellerTipp[b] = Tippzahlen[generator.Next(1, 50)];
            while (aktuellerTipp[b] == 0);
            Tippzahlen[aktuellerTipp[b]] = 0;
        }
        Array.Sort(aktuellerTipp);
        foreach (byte b in aktuellerTipp)
            Console.Write(b+" ");
        Console.Write("SZ " + generator.Next(0, 10));
        Console.ReadLine();
    }
}

Der Nachteil an dieser Methode ist, dass man über 56 Arrays braucht. Würdest z.B. du als erfahrener Progammierer einen ähnlich "aufwendigen" Code ohne Bedenken einsetzen wenn er voll funktionstüchtig ist?
Der zweite Tipp von dir ließe sich bei mir nur mit einer ziemlich langen If-Bedingung lösen oder einer doppelten verschachtelten Schleife 🤔 Wie liesse sich hier nur mit 6 Arrays die Zahlen vergleichen?

Einen schönen Sonntag nachmittag,

ich bin jetzt mit einem primitiven Lottogenerator fast fertig. Nur gibt er manchmal doppelte Zahlen aus.

using System;

class Lottoglueck
{
    static void Main()
    {
        byte[] Tippzahlen = new byte[6];
        Random generator = new Random();
        Console.WriteLine("Lotto");
        for (byte b = 0; b < 6; b++)
        {
            Tippzahlen[b]= (byte) generator.Next(1,50);
        }
        Array.Sort(Tippzahlen);
        foreach (byte b in Tippzahlen)
            Console.Write(b+" ");
        Console.Write("SZ " + generator.Next(0, 10));
        Console.ReadLine();
    }
}

Ein guter Algorithmus für die Vermeidung von doppelten Zahlen bzw. Aussortieren gezogener Zahlen will mir einfach nicht einfallen -.-

Habs verstanden, danke 👍

Ah, das war ein böser Denkfehler 8o

Das erste ist abgehakt 👍

Das mit dem 2. Problem (also die Aussage der angeblichen Unveränderlichkeit bei Array in foreach-Schleifen) ist also falsch? (Mit den Enumeratoren-Vergleich an dieser kann ich noch nicht anfangen, hab ich mir aber notiert)

Einen schönen Sonntag nachmittag,

beim Erlernen der Array-Funktionen bin ich auf zwei Hindernisse gestossen:

Nachdem ich alle Arrays gleiche Werte zugeteilt habe, möchte ich Arrays mithilfe der Foreach-Schleife anzeigen lassen:

using System;

class Programm2
{
    static void Main()
    {
        byte[] zahl = new byte[5];
        for (byte i = 0; i < 5; i++)
        {
            zahl[i] = 4;    // Geht nur wenn das Array einen Wert UNTER seiner Index-Grenze enthält
            Console.WriteLine(zahl[i]);
        }

        Console.WriteLine("");

        foreach (byte i in zahl)
            Console.WriteLine(zahl[i]); // Hier ist die Absturzstelle
        }
    }
}

Das Programm stürzt an der zweiten kommentierten Stelle ab, wenn bei der ersten kommentierten Zeile ein Wert zugewiesen worden ist, welcher höher als das Index (also 5 und darüber) ist.

Mit der For-Schleife ginge das problemlos, aber zeitaufwändiger. Zumal ich mich wundere, dass es nicht mit der foreach-Schleife funktioniert, weil ja hier auch nur ein Lesezugriff geschieht.

Anschließend kam ein 2. Problem auf:

Ein Verändern der Arrays sei ja innerhalb der Foreach-Schleife nicht möglich, meinte mein Tutorial-Buch.

Tatsächlich funktioniert es aber

foreach (byte i in zahl)
        {
            zahl[i] = 3; // Hier ist die Absturz
            Console.WriteLine(zahl[i]);
        }

wenn auch die gleichen Einschränkungen gegeben sind (also Werte sind maximal bis zum Indexwert gültig).

Hallo,

ich versuche mich nun an an das Antme! Projekt.
Selbst die aktuellste Fassung muss in Visual C# 2008 9.0.3 / Framework 3.5 neu erstellt werden. Das geschieht aber fehlerfrei und ohne Warnmeldungen.
Nur kommt es scheinbar sporadisch, also unregelmäßig, zu folgender Fehlermeldung, wenn man die Vorlage.cs bzw. eine Kopie davon ausführt:

Der Namespace "AntMe.Spieler" enthält bereits eine Definition für "MeineAmeise".

Hat jemand eine Ahnung, wie ich den Fehler beheben kann?

Grüße

Edit:

Hier ist der Code:

using System;
using System.Collections.Generic;
using System.Text;
using AntMe;

namespace AntMe.Spieler {

	[Spieler(
		Name = "",
		Vorname = "",
		Nachname = ""
	)]

    // Das Typ-Attribut hier erlaubt das Ändern der Ameisen-Eigenschaften. Um hier Änderungen vorzunehmen muss
    // dem neuen Ameisentyp unbedingt ein Name zugewiesen und bei "BestimmeTyp" auch angegeben werden.
    // Eine genauere Beschreibung gibts in Lektion 6 des Ameisen-Tutorials
	[Typ(
		Name = "",
		GeschwindigkeitModifikator = 0,
		DrehgeschwindigkeitModifikator = 0,
		LastModifikator = 0,
		ReichweiteModifikator = 0,
		SichtweiteModifikator = 0,
		EnergieModifikator = 0,
		AngriffModifikator = 0
	)]

	public class MeineAmeise : Ameise {

        /// <summary>
        /// Gibt dem Spieler die Möglichkeit, eigene Variablen zu initialisieren.
        /// Wird vor jedem Spiel aufgerufen. Statische Variablen müssen hier
        /// initialisiert werden!
        /// </summary>
		public static void Initialisiere() {
		}

        /// <summary>
        /// Bestimmt den Typ einer neu zu erzeugenden Ameise.
        /// </summary>
        /// <param name="anzahl">Anzahl der vorhandenen Ameisen pro Typ</param>
        /// <returns>Name des Typs</returns>
		public static string BestimmeTyp(Dictionary<string, int> anzahl) {
			return "";
		}

        /// <summary>
        /// Der Ameise Konstruktor.
        /// </summary>
        /// <param name="volk">Das Volk zu dem die neue Ameise gehört</param>
        /// <param name="typIndex">Der Typ der neuen Ameise</param>
        public MeineAmeise(Volk volk, int typIndex)	: base(volk, typIndex) {
		}

		/// <summary>
		/// Wird aufgerufen, wenn die Ameise nicht weiss wo sie hingehen soll.
		/// </summary>
		public override void Wartet() {
		}

		/// <summary>
		/// Wird einmal aufgerufen, sobald die Ameise ein Drittel ihrer maximalen 
		/// Reichweite überschritten hat.
		/// </summary>
		public override void WirdMüde() {
		}

		/// <summary>
		/// Wird aufgerufen, wenn die Ameise einen Zuckerhaufen sieht.
		/// </summary>
		/// <param name="zucker">Zuckerhaufen</param>
		public override void Sieht(Zucker zucker) {
		}

		/// <summary>
		/// Wird aufgerufen, wenn die Ameise ein Stück Obst sieht.
		/// </summary>
		/// <param name="obst">Obst</param>
		public override void Sieht(Obst obst) {
		}

		/// <summary>
		/// Wird aufgerufen, wenn die Ameise einen Käfer sieht.
		/// </summary>
		/// <param name="käfer">Käfer</param>
		public override void Sieht(Käfer käfer) {
		}

		/// <summary>
		/// Wird aufgerufen, wenn die Ameise eine Markierung sieht.
		/// </summary>
		/// <param name="markierung">Markierung</param>
		public override void Sieht(Markierung markierung) {
		}

		/// <summary>
		/// Wird aufgerufen, wenn die Ameise von einem Käfer angegriffen wird.
		/// </summary>
		/// <param name="käfer">Käfer</param>
		public override void WirdAngegriffen(Käfer käfer) {
		}

		/// <summary>
		/// Wird aufgerufen, wenn die Ameise bei einem Zuckerhaufen ankommt.
		/// </summary>
		/// <param name="zucker">Zuckerhaufen</param>
		public override void ZielErreicht(Zucker zucker) {
		}

		/// <summary>
		/// Wird aufgerufen, wenn die Ameise bei einem Stück Obst ankommt.
		/// </summary>
		/// <param name="obst">Obst</param>
		public override void ZielErreicht(Obst obst) {
		}

		/// <summary>
		/// Wird aufgerufen, wenn die Ameise gestorben ist.
		/// </summary>
		/// <param name="todesArt">Die Todesart der Ameise</param>
		public override void IstGestorben(TodesArt todesArt) {
		}

		/// <summary>
		/// Wird in jeder Runde aufgerufen.
		/// </summary>
		public override void Tick() {
		}

	}

}

++:::

Pfff... habe die Lösung versteckt in der Hilfe gefunden - sinnigerweise erst nach den ersten Ausführungsversuchen. Letzere war wohl nicht auf dem neuesten Stand 😠 Kurz: Die Kombination aus dem Namensraum und dem Klassennamen aller Ameisen in einem Spiel war nicht eindeutig.

@ nitronic:

Wiegesagt, konnte ich die Quelle nach solanger Zeit nicht mehr auffinden. Dazu unten mehr. Den Inhalt habe ich natürlich in keinster Weise verändert, wenn auch die Form darunter geleidet hat.

Das ändert an der Sachlage nichts

Das ist schade drum. Und ich habe etwas recherchiert und muss dir wiedermal Recht geben. Allerdings sollten die Umstände im Falle eines Falles eine strafmildernde Wirkung haben (wobei es strafbar bleibt). Und 70 Jahre auf eine Verjährung des Copyrightes zu warten... hmmm da habe ich noch andere Sachen zu tun 🤔

Der augenscheinliche Gedanke war nur, das niemand zu Schaden käme und alle profitieren: Der private Homepagebesitzer kann Material zur Verfügung stellen; der Urheber wird über seine Grenzen bekannt; die Nutzer finden die Infos an verschiedenen Infos.
Ich meine, warum sollte der Urheber sonst seine Werke frei ins Internet stellen (meist hat keine Homepage)? Da ist eine Vervielfältigung doch erwünscht. Aber du hast die Antworten ja oben schon gegeben.

Eine Vervielfältigung ist dann erwünscht, wenn dies ausdrücklich erwähnt wird. Ausserdem stellt jemand seinen Content ins Internet, damit dieser verlinkt und nicht an anderer Stelle erneut angeboten wird. Schließlich möchte ich als Urheber mehr Traffic generieren. Möchte ich es beispielsweise nicht auf meiner eigenen Website publizieren, sondern an anderer Stelle, dann suche ich mir etwas mit großer Reputation. Siehe codeproject.com o.ä.

Was das Thema "über die Grenzen hinweg bekannt werden" angeht: Wo sei gesagt, dass dies mit deiner Website so ist? Weder kennt man Klickraten, noch sonstige weiterführende Informationen. Dein Gedanke selbst mag gut gemeint sein, entspricht aber weder der rechtlichen Grundlage, noch dem Willen der meisten Urheber.

Wie ich bereis schrieb: Viele Autoren haben gar keinen Webspace. In diesem so gar nichtmal speziellen Fall kann man doch guten Gewissens von Vervielfältigungswünschen ausgehen. (Bevor du mich drauf hinweist: ja, ich frage trotzdem).

Ich habe mal eben spontan "norbert eder gdi" eingegeben... du hast Recht. Das scheine ich übersehen zu haben?! Ich kann dir aber versichern, dass das nicht absichtlich passiert ist. Das überrascht mich insofern selbst.

Ich unterstelle dir keine Absichtlichkeit, sondern Blauäugigkeit.

Die Blauäugigkeit habe ich beim letzten Mal noch überlesen. Ich bin also gleich mehrfach blauäugig weil ich das Recht nicht 100%ig auswendig kenne und Vermutungen anstelle. Zudem war dein Beispiel mit den Bildern im letzten Post unpassend (solche Copyright-Verstöße sollten nummermehr jedem bekannt sein). Und das mit dem URL-Grabber ist eher der Apfel-Birnenvergleich (ganzer Seitenklau, keine Hinweise).

Letzenendlich würde ich dich bitten, eine Backupkopie deines Inhalts auf meinen Server bzw. Computer anzufertigen zu dürfen, um in Falle eines Falles nicht auf den externen Link angewiesen zu sein (welcher i.d.R. als einzige Quelle fungiert).

Der Artikel steht auf einer Plattform mit über 200.000 Benutzern (tutorials.de) und ich sehe keinen Sinn dahinter ein "Backup" für eine Seite mit 10 Visits pro Tag anzufertigen. Sorry. Du kannst gerne verlinken, das steht dir frei.

Bist du dir da sicher? Eine der ehemalig größten deutschen Internetseiten musste Anfang dieses Jahrtausend trotz eines Relaunches schließen (der Name ist mir aber momentan entfallen). Auch sicher keine Unbekannte war das k-Hardware-Netzwerk, welches trotz vielen Besuchern schließen musste. Das Web ist immer noch schnelllebig. Da sind kleinere Seiten i.d.R. sicherer. Zwar zugegebenermaßen nicht auf den neuesten Stand, aber man kann davon ausgehen, dass der Inhalt noch einige Zeit geben wird. Beispiele, welche Seiten bis ins Jahr 199x reichen, kann ich dir gerne geben. Kleine Seiten (wie die meinige) stellen zu den großen Anlaufpunkten des Webs eine Ergänzung dar. Ich finde auch an dieser Stelle trifft dein Tonfall einen leicht überheblichen Beigeschmack. Eine kleine Rücksalve Bläuaugigkeit.

Ich gehe mal davon aus, dass du ein Backup nicht gestattest.

Da gab es das Problem, dass z.T. die Quellen nicht mehr existierten und da wollte ich mir etwas Arbeit ersparen mit mühseligen, oft vergeblicher Mikrosuchen. Zu zweiten Punkt ist noch zu beachten, wielange man auf eine Antwort warten darf? Manchmal bekomme ich überhaupt keine Antwort (über 2 Wochen), ob es dann verpönt ist, das Material online zu stellen? Das wäre wirklich schade!
Ich kann mir die Antwort schon denken

Wenn du keine Antwort erhältst, dann ist das gleichzusetzen mit einer Absage. Dies bedeutet für dich, dass du diesen Content nicht verwenden darfst.

Über solche Antworten freue ich mich schon mehr 🙂

Die unkommentierten Stellen schließe ich mich kommentarlos an.

Danke für deine entgegengebrachte Zeit, für mich wäre alles nummermehr alles endgültig geklärt. Klar, ist es dein gutes Recht noch zu antworten, wenn es noch nötig ist.

Verzeihe mir die Grammatik-/ Rechtschreibfehler um diese späte Zeit.

@ Golo Roden:

Auch noch eine case-sensitive Implementation? 👅 Klar habe ich deinen Vorschlag berücksichtigt; schließlich hat mir deine Site ja auch geholfen 👍

@ herbivore:

Hmm, deine Beispiele sind wohl eher Ausnahme, aber die Nachricht, die du übermittelst wolltest, ist angekommen. Kurz: Keine Eigenjustiz.

Also für mich hat sich das Thema nun erledigt. Etwas schade für älteres Material, nungut, das ist gefressen.

Gute Nacht

Hallo herbivore,

ich habe mir erlaubt den Link wieder reinzusetzen, nachdem ich nur noch die externen Links am Leben gelassen habe. Lieber die Hälfte als gar nichts.

Zu nitronics Beitrag:

Eine Antwort von mir bekommst du aus Zeitgründen erst morgen oder später von mir an dieser Stelle. Ich denke wenn wir es erstmal öffentlich ausdiskutiert haben, könnte der Thread als Muster für ähnliche Problemstellungen für andere ganz hilfsreich sein. Zudem für mich persönlich aufgrund meines baldigen Projektes die Probleme dann erst richtig anfangen dürften (mit gut tausend Quellen).

EDIT: So, dann nehme ich mir mal auch die Zeit, auf deinen ausführlichen Beitrag einzugehen:

Mein GDI+ Artikel wurde ursprünglich als PDF auf meiner Website angeboten und später auf tutorials.de publiziert. Auf meiner Website ist es nicht mehr vorhanden, das ist korrekt so.

Aber:
a) Dieser Artikel wurde von mir unter oben genannten Link der Öffentlichkeit zur Verfügung gestellt. Dies bedeutet, dass ihn jeder lesen und die Beispiele darin ausprobieren kann. Es heißt jedoch nicht, dass dieser Content verwendet wird, um ein 10-Sekunden PDF daraus zu erstellen und auf der eigenen Webseite zu hosten.

Wiegesagt, konnte ich die Quelle nach solanger Zeit nicht mehr auffinden. Dazu unten mehr. Den Inhalt habe ich natürlich in keinster Weise verändert, wenn auch die Form darunter geleidet hat.

b) Ja, du hast natürlich meinen Namen angemerkt. Gut. Aber hast du mich auch gefragt, ob ich diesen Artikel überhaupt auf deiner Site sehen möchte? Nein, hast du nicht. Und genau da liegt das Problem.

Deinen Namen habe ich mir nicht gemerkt, ich wusste es nur anhand deiner Signatur in diesem Thread nachträglich, dass du es bist.

Du selbst schreibst in deinem Impressum:

Zitat:
Alle unter wubb.de veröffentlichten Texte und Bilder unterliegen dem Urheberrecht von (Name entfernt) und dürfen nur mit ausdrücklicher Erlaubnis mit Quellenangabe kopiert, weitergeleitet oder vervielfältig werden. Bei elektronischer oder schriftlicher Veröffentlichung ersuche ich um eine kurze Benachrichtigung per E-Mail und um ein Belegexemplar.

Du willst also, dass man dich um ausdrückliche Erlaubnis fragt, ebenso, dass die Quelle angegeben wird (eine Quellenangabe im Internet enthält auch immer die Angabe der URL unter welcher der Inhalt gefunden wurde) und du bittest um eine kurze Benachrichtigung als auch ein Belegexemplar.

Wieso tust du nicht das, was du von anderen erwartest? Und wieso willst du das Belegexemplar? Ganz klar. Du willst ja schließlich nicht, dass es absolut billig aussieht und somit eventuell dein Name an Reputation verliert. Genau das sehe ich auch so.

Ich bin in der Community tätig, weil ich gerne Menschen helfe. Daher stelle ich auch Inhalte zur Verfügung. Ich bekomme jedoch einen Hals², wenn einfachste Grundlagen nicht eingehalten werden. Und das ist hier auch der Punkt.

Hmm, ja das ist ein wunder Punkt an dieser Geschichte, das möchte ich nicht verschleiern. Das Impressum habe ich vor einem knappen Jahr aufgesetzt. Eigentlich war das im ewigen Aufbau befindliche PC-Guide damit gemeint.
Ich habe das Impressum wohl zu streng formuliert und werde es abändern, dass ich keine Benachrichtung brauche aber die Quelle angegeben werden muss, sowie unveränderter Inhalt. Danke für den Hinweis. Deine Kritik ist absolut berechtigt.

Der augenscheinliche Gedanke war nur, das niemand zu Schaden käme und alle profitieren: Der private Homepagebesitzer kann Material zur Verfügung stellen; der Urheber wird über seine Grenzen bekannt; die Nutzer finden die Infos an verschiedenen Infos.
Ich meine, warum sollte der Urheber sonst seine Werke frei ins Internet stellen (meist hat keine Homepage)? Da ist eine Vervielfältigung doch erwünscht. Aber du hast die Antworten ja oben schon gegeben.

Du konntest den von mir angebotenen Inhalt im Internet nicht mehr finden? Und das obwohl du gesucht hast? Nein. Bei Google stehts an erster Stelle wenn nach dem Titel gesucht wird. Auch auf CodeZone ist eine Verlinkung zu finden (auf Google übrigens an 3. Stelle).

Ich habe mal eben spontan "norbert eder gdi" eingegeben... du hast Recht. Das scheine ich übersehen zu haben?! Ich kann dir aber versichern, dass das nicht absichtlich passiert ist. Das überrascht mich insofern selbst.

Wie schon erwähnt: Namentliche Quelle reicht nicht. Eine Quellenangabe umfasst auch den Link zu einer vertrauenswürdigen Fundstelle bzw. zum Content-Ersteller. Anfragen müssen VOR der Veröffentlichung eingeholt werden.

Da gab es das Problem, dass z.T. die Quellen nicht mehr existierten und da wollte ich mir etwas Arbeit ersparen mit mühseligen, oft vergeblicher Mikrosuchen. Zu zweiten Punkt ist noch zu beachten, wielange man auf eine Antwort warten darf? Manchmal bekomme ich überhaupt keine Antwort (über 2 Wochen), ob es dann verpönt ist, das Material online zu stellen? Das wäre wirklich schade!
Ich kann mir die Antwort schon denken

Zitat:
Wenn meine Site kommerziell und voller Werbung wäre, hätte ich das alles mit Sicherheit nicht reingestellt. Sie ist und bleibt aber privat und werbefrei (mit gemeinnützigem Hintergedanke). Ob das was an der Sachlage ändert?

Nein. Tut es nicht.

Da müsste ich nochmal genau recherchieren. Kann dazu nichts weiter sagen.

Letztendlich habe ich drüber nachgedacht, und meine mich erinnern zu können, deine GDI-Tipps aus einem Forumthread in die Txt-Datei kopiert zu haben.
Es gibt wohl ein entscheidendes Motiv, was mich dazu veranlasst, Daten nochmal selbst anzubieten:

Die Angst, die Quellen könnten verschwinden aus dem schnelllebigen www (ganz besonders Foren). Die Erfahrung spricht leider dafür. Als Beispiel sei http://3dconcept.ch/ genannt; die Site verlottert seit Jahren und vieles aufwändig ausgearbeitetes Content ist unwiderruflich im Nirwana verschwunden.

Summa summarum - Du hast mich überzeugt. Ich werde künftig eine Protokollierung meiner Anfragen anfertigen. Ich weiß noch nicht wie ich auf unbeantwortete Antworten reagiere, aber das werde ich auch noch herausbekommen. Zwar steigt nun der Aufwand enorm an (20% an Zeit die ich auch an Qualitätsverbesserung verwenden hätte können), aber es ist unvermeidlich, wie du aufgezeigt hast. Zumindest Guter Willen oder Symbiose-Gedanken hin oder her, das zählt eben nicht. Man kann froh sein, dass Verlinkungen nicht angefragt werden müssen.

Letzenendlich würde ich dich bitten, eine Backupkopie deines Inhalts auf meinen Server bzw. Computer anzufertigen zu dürfen, um in Falle eines Falles nicht auf den externen Link angewiesen zu sein (welcher i.d.R. als einzige Quelle fungiert).

Gute Nachtruhe allerseits,

hdsf

Hallo,

den werde ich noch anfragen.

Wenn meine Site kommerziell und voller Werbung wäre, hätte ich das alles mit Sicherheit nicht reingestellt. Sie ist und bleibt aber privat und werbefrei (mit gemeinnützigem Hintergedanke). Ob das was an der Sachlage ändert?

Ich sehe schon, das Thema driftet etwas in die falsche Richtung ab, nicht so wie vorgestellt 😭

Hi,
ich erlaube mir mal, öffentlich dazu Stellung zu geben.

das waren halt meine Notizen, die ich über Jahre hinweg im Web gesammelt habe. Da kann ich bei einem oder anderen Dokument trotz Anwerfen der Suchmaschinen nicht mehr finden. Und da sehe ich den Vorteil des verteilten Web, dass sich gute Information, also auch deine, übers Wasser hält, während unwichtige Informationen mit der Zeit gefiltert werden. Auf der anderen Seite verschwinden auch (subjektiv) wichtige Informationen vom web vollständig, da bietet sich das mit dem Upload doch an. Ich habe also nur solche Dokumente hochgeladen, welche Informationen ich anderweitig nicht mehr gefunden habe.

Bis auf eine Ausnahme habe ich die Quellen namentlich immer erwähnt. Bei einigen steht noch eine Anfrage aus.

Ich persönlich würde mich freuen, wenn mein frei angebotenes Material, wo ich keine Verteilungsbeschränkungen vermerkt habe natürlich (unverändert) weitergegeben wird. Bei dir habe ich es irgendwann in eine txt reinkopiert aus welchen Gründen auch immer und diese der Form halber in PDF konvertiert.

Ich setze mich für ein weltoffenes Internet mit Hyperlinks ein. Das heißt natürlich nicht, dass man damit sämtliche Coprights missachtet. Ich wehre mich aber gegen die Behauptung, deren Inhalte als zueignen gemacht zu haben. Wie auch immer der Grat zwischen nützlicher Informationsweitergabe und störendes Copyright ist immer schwierig und rechtlich oft schwammig.

Das ist nur meine Ansicht.

Da die GDI-Einführung dein Inhalt ist, habe ich es erstmal wieder vom Netz genommen. Gerne verlinke ich auch auf deine Seite ect.

Hallo,

ich war heute so frei und habe den heutigen Vormittag damit verbracht, den Großteil meiner gesammelten, frei verfügbaren C# Dokumente zu gliedern und hier ist das Ergebnis: http://cs.wubb.de .
Diese kleine Sammlung soll auch ein kleines "Danke schön" an die hilfsreichen User hier sein (Grüße an herbivore, norman_timo und natürlich allen anderen dir mir geholfen haben) 🙂

@crische5: eben nicht mit byte. talla und egrath haben ja darauf eine Antwort 🙂

So einfach ist das also 🤔
Alles klar 😁

Hallo,
meine letzte Frage dieses Jahr an euch:

Kann mir jemand sagen, warum dieses Beispiel nicht funktioniert?

byte zahl = 1;
zahl = zahl + Convert.ToByte(3);

Okay, und wieder ein Stück weiter - danke schön! 👍

Hallo,
wie den meisten von euch bekannt sein dürfte, wird zwischen Wertetypen (elementare Datentypen wie int, double usw.) und Referenztypen (Klassen, Arrays, string) unterschieden.
Wenn ein Wertetyp übergibt wird, so wird er standardmäßig den Wert der formalen Parameter des Ausrufers nicht ändern (es sei denn man verwendet das Schlüsselwort ref). Ein Referenztyp wird hingegen nach dem Aufruf auch im Ausrufer verändert übernommen, weil die Variable ja direkt auf das Objekt weist.

Bei Arrays klappt es, Klassen konnte ich noch nicht ausprobieren, aber Strings werden nicht verändert übernommen?!

Wo ich gerade den Thread eröffnet habe, gibt es ein Schlüsselwort welche Referenztypen wie Wertetypen behandelt, also nicht ändert, also das Pendant zu ref?

Schönen Morgen noch, diesmal ohne Fragen von mir schon verstanden 🙂

Bei Threads habe ich bisher nämlich nur eine Methode kennen gelernt - System.Threading.Thread.Sleep(x). Das gleiche scheint auch bei Arrays zu sein (da kenne ich momentan nur Array.Sort(ArrayBez) ). Dein Feedback und Know-How erleichtert verkürzt mir den langen Weg, indem ich nicht weniger auf Holzwegen bin; 👍

[EDIT]Abgeteilt von Objektorientierung erlernen[EDIT]

Eine gute Nachricht: Ich habe das Beispiel doch noch gerafft und bin wieder beim ersten Buch 😁
Jetzt hat sich das irgendwie nach stundenlangen Nachdenken meine Frage / Ansicht zum Gegenteil entwickelt: Ich verstehe lediglich nicht, die Klasse Console bzw. Thread über den Klassennamen angesprochen wird, obwohl man es sich doch sehr gut als Objekte vorstellen könnte. Zumindest möchte ich wissen, ob ich in der Theorie recht habe (also logisch) oder falsch denke. Ich glaube, es geht über den Klassennamen, weil man praktisch keine 2. Konsole braucht, bzw. beim Thread es eine spezielle, bessere Lösung gibt.

Ja, Herbivore, da muss ich mich wohl tatsächlich durch den OO-Kram erkämpfen. Danke schön.

Hallo juetho,

danke für die Antwort. Dieses Buch habe ich mir schon angesehen, aber die Zielgruppe sind Leute, die mit OO schon was gemacht haben - also fortgeschritten.

Hallo,

obwohl ich 3 C# Anfängerbücher parallel bearbeite, haben sie alles was gemeinsam: Sobald Objekte ins Spiel kommen, könnte ich weiterprogrammieren, verstehe aber den Zusammenhang nicht zwischen Erklärung und praktischer Umsetzung. Ich weiß z.B. das Objekte Instanzen einer Klasse bilden, also eine Kopie nach den Vorgaben der Klasse ist.
Tatsächlich sehe ich aber nur Klasse und Methoden wie eine prozedurale Sprache. Mich verwirrt z.B. das GetType() objektorientiert ist, aber z.B. Random(), welches auch objektorientiert ist. statt zahl.random() ein neues Objekt erwartet, obwohl zahl ja eine objekt der Klasse z.B. int ist usw.
Hat jemand gute Vorschläge eines OO-Buch / Tutorials von Urschleim an?

Huii, vielen dank! Ich muss intensiver suchen! Dann lassen sich die Shortcuts besser einprägen!

EDIT: Ist ja dieses Jahr herausgekommen, hmm hätten Sie ja fast Vc# 2007 nennen können...

Hallo,
um die Internetleitungen zu schonen, habe ich nach einer Neuinstallation des OS Visual C# 2005 von der offziellen CD installiert statt es aus dem Internet runterzuladen.
Komischerweise sind die Standard-Shortcuts andere als ich gewohnt bin:
Statt [Strg]+[Buchstabe],[Nocheinbuchstabe], sind alle Shortcuts nun
[Strg] + [Buchstabe],[nochmal Strg]+[Nocheinbuchstabe] gegliedert.

Version ist VC# 8.0.5 - NET 2.0.5

Ansonstens sollten die Änderungen marginal sein, oder lohnt es sich, die neueste Version runterzuladen?

Gut erklärt, jetzt verstehe sogar ich das 👍

Danke für die schnelle Antwort egrath, habe ich mir notiert. Gelten diese Grenzen nun immer schrittweise (wie FAT-System-Einteilung in 4kb) oder nur für die Mindestgrenze. Letzeres kann ich so herausinterpretieren und erstere ist mir aber wahrscheinlicher.

Hallo,
ja ich bin immer noch bei den Konsolenanwendungen 🙂
Nun habe ich die Veröffentlichen-Funktion ausprobiert und wollte sehen, wie effizient der C# Compiler ist. Also habe ich mehrere Variationen des "Hello World!" Programms veröffentlicht.
Mich macht es stutzig, dass die Dateigröße in allen Fällen identisch ist (5.321 Byte). Erst dachte ich, ok, C# ist super effizient und macht aus meinen verknüpften bzw. doppelten Write() Methoden eine einzige und daher sind die Dateien gleich groß. Ich denke, das trifft zu 🙂
Aber ich kann mir nicht erklären, warum die Ausgabe"Hello World" und "Hello World!!" aufs Byte genau gleich groß sind? Letztere hat zwei Strings mehr, müsste also 32 Bit, d.h. 4 Byte größer sein. Aber genau das ist nicht der Fall.

Wo ich gerade von der Veröffentlichungsfunktion spreche: Gibt es ein schnelleres Verfahren als die Veröffentlichung, die exakte Dateigröße abzulesen? Ich meine, alle mit [F5] bzw. [Strg]+[F5] erstellten Builds sind immer exakt 16 kbyte groß, eignen sich also nicht für Größenvergleiche, es sei denn ich habe was übersehen.

Genauso meinte ich es! War für mich verwirrend wie ein endlose Projektion (vergleiche laufende Kamera ins Kamerabild halten) - thx 👍

Danke, aber solche Banalitäten (?) sind mir schon bekannt.
Die Frage ist nicht danach, sondern davor, es geht hier um vorgefertigte Klassen. Woher nimmt der csc Kompiler die Informationen?
Also das Problem ist, ich erkenne keinen theoretischen Unterschied zwischen Anweisungen und eigene Methoden. Wo ist die Quelle der Anweisungen.
Ich versuche es mal so zu formulieren:
Bei selbsterstellten Programmen sind jene Anweisungen wie WriteLine() der kleinster Nenner. Doch dieser kleinste Nenner stellt ja selbst eine Methode, also muss es noch einen kleineren Nenner bzw. Einheit geben?!

Guten Abend,
insoweit habe ich das theoretische Blabla von C# in Griff.
Z.B. ist die Anweisung WriteLine("Hier bin ich!"); ja genau genommen ein Methodenaufruf.
Wie sehen also die Anweisungen für WriteLine() eigentlich an sich aus? Sind das schon die binärkodierten Entsprechnungen oder wieder Zwischenschritte? Bringt mich ein bissel durcheinander!
Ich habe schon die MSCOR.LIB mit Notepad geöffnet; findet sich aber nix erklärendes.
Vielleicht weiß ja jemand von euch über diese paradoxe Unlogik besser Bescheid?