Hallo zusammen,

mir ist eine Sache nicht ganz klar, und ich hoffe, dass mir hier jemand weiterhelfen kann.

Nehmen wir mal folgende Situation:*Ich habe ein Steuerelement programmiert. *Da ich eine globale Assembly erzeugen will, verpasse ich der DLL einen StrongName, in dem ich die Versionsnummer setze und einen Schlüssel erzeuge. *Ich veröffentliche dieses Steuerelement mittels Installer. *Da ich sicherstellen will, dass der Anwender immer die aktuelle Version meines Steuerelementes einsetzt, installiere ich die DLL in das vom Anwender gewählte Verzeichnis und in den GAC. *Der Anwender erstellt nun eine Anwendung, welche mein Steuerelement einsetzt. *Da ich die DLL in den GAC installiert habe, erhält der Anwender keine lokale Kopie im Bin-Verzeichnis seiner Anwendung.

Meine Frage nun:
Was muss der Anwender machen, wenn er seine Anwendung, die ja mein Steuerelement enthält, weitergeben will.
Muss er dann meine DLL mitgeben?

Wenn ich in einer Anwendung 20 Steuerelemente von Drittanbietern nutze, muss ich die dann alle weitergeben, wenn ich meine Anwendung veröffentliche? 8o

Hallo Ihr beiden,

vielen Dank für Eure Antworten.

@JuyJuka
Das mit der Mehrzahl finde ich auf den ersten Blick recht gut 👍

@Haggy
Klar, ein Namensraum soll einen Oberbegriff darstellen.
In meinem aktuellen Beispiel ist es in der Tat so, dass ich ein Steuerelement mit dem (Pseudonamen) TestButton erzeugen möche.

Da dieses Steuerelement das grundlegende (bzw. das einzige) Element dieses Namespace ist, sollte der Name der Klasse schon mit in den Namespace integriert werden. Wegen der Gleichheit, bietet es sich da doch an, einfach ein 's' anzuhängen.

Klar, bei einer komplexen Anwendung, hat man mehrere Möglichkeiten.

Ich bin für weitere Vorschläge offen 😉

Hallo zusammen,

folgende Situation:

Ich habe eine (fiktive) Klasse TestButton.
Diese befindet sich in dem (fiktiven) Namespace PeterLustig.TestButton.Core

Binde ich diesen Namespace in irgendeine Codedatei ein, so kann ich die Klasse TestButton dennoch nur über ihren vollqualifizierten Namen ansprechen, da die IDE bzw. der Compiler sonst anscheinend Klasse und Namespace nicht unterscheiden kann.

Benenne ich den Namespace um, in bspw. PeterLustig.TestButton_NS_.Core, so funktioniert der Zugriff ganz simpel über den Klassennamen.

Fazit: Ist der Name einer Klasse ein Teil des Namens ihres Namespaces, so lässt sich die Klasse ausschließlich über ihren vollqualifizierten Namen ansprechen.

Ich hätte jetzt zuerst dazu tendiert, den Namespace dann einfach abzukürzen, bspw so PeterLustig.TB.Core, allerdings habe ich im guide to C# gelesen, dass man das nicht machen sollte.

Wie handhabt Ihr das? Wie bezeichnet Ihr Eure Namensräume und die dort enthaltenen Klassen?

Hallo balmac,

wollte Dir nur mal sagen, dass Du nicht alleine bist.
Ich komme zwar aus der Delphi-Ecke, kann Dein Problem aber voll und ganz nachvollziehen.

Während es sehr einfach war, Hilfe für Delphi zu finden, besteht bei C# der Großteil meiner Arbeit aus der Suche nach den richtigen Informationen.

Ich tue mich besonders mit der Terminologie recht schwer; manchmal weiß ich einfach gar nicht, nach was ich suchen muss, wie dieses oder jenes in C# benannt ist.

Ich denke, die Ursache liegt unter anderem auch darin, dass C# noch nicht soooo alt ist, die Community folglich noch nicht so gewachsen.
Das fällt mir gerade im deutschsprachigen Raum immer wieder auf; Suche mal nach einer Community für C# - da wirst Du außer mycsharp.de nicht viel finden.

Im amerikanischen Raum sieht das schon wieder ganz anders aus; da sind die Microsoft-Technologien viel stärker vertreten, als bspw. CodeGear.

Wenn man aber erstmal das gefunden hat, was man sucht (im MSDN) - und da stimme ich Peter Bucher vollkommen zu - dann ist das sehr ausführlich und verständlich beschrieben.

Ich denke mal, dass sich das mit der Zeit einspielt, und wir irgendwann einfach wissen, wie und wo wir nach was suchen müssen.

Hallo,

danke für Deine Antwort.

Der verlinkte Beitrag hatte mich schon auf den richtigen Weg geführt.

Habe einfach nochmals ein 'Windos Forms Steuerelement'-Projekt gestartet und dieses dann nicht von UserControl abgeleitet, sondern von Button.

Hallo zusammen,

wenn ich eine Klasse habe, die bspw. von Button abgeleitet ist, dann erscheint diese ja nach dem Erstellen in der Toolbox, so dass ich diese zur Designzeit auf das Formular ziehen kann.
Meine Klasse erscheint also als Steuerelement in der Toolbox.

Nun habe ich mich auf die Suche gemacht, wie ich diese Klasse persistent als Steuerelement verfügbar machen kann, also dauerhaft, und nicht nur, wenn ich dieses Projekt bearbeite.

In der MSDN und auch hier finde ich immer wieder 'UserControl'.
Habe daraufhin einfach mal ein neues Projekt "Windows Forms Steuerelement" gestartet, was wohl einem 'UserControl' entspricht.

Das ist allerdings nicht das, was ich möchte, da ich mein Control ja im Prinzip schon habe.

Muss sich meine Klasse dazu einfach in eine DLL packen, oder wie funktioniert das?
Ein Link o.ä. der mir weiterhilft, wäre nett.

Vielen Dank.

Edit: bin nun auf diese Seite gestossen, und hoffe, dort Antworten zu finden. Daher setze ich diese Frage erstmal auf beantwortet,

Ups,

mir war absolut nicht bewusst, dass es in C# so ohne weiteres möglich ist, aus einer Klasse eine Komponente (in Delphi heißt es so) zu machen, bzw. dass das automatisch geschieht 8o

Unter diesen Umständen ist natürlich vollkommen klar, was Du meinst.

Danke!

Hallo JAck30lena,

vielen vielen Dank für Dein Feedback 👍

(ist ja leider nicht so üppig, was hier sonst so zurückkommt X( )

zu 1:
Das verstehe ich ehrlich gesagt nicht so ganz.
Da es sich bei der Klasse nicht um eine Komponente (heißt das in C# so?) handelt, die ich zur Designtime auf der Form platzieren kann, kann ich sie nur zur Runtime erzeugen.
Dabei muss ich dann doch angeben, welches das Parent-Control sein soll.

Meinst Du, es wäre besser, anstatt

HandyButton hb11 = new HandyButton(this, textBox1, new Point(xOffset + 2, yOffset + 2), new char[] { '1', '-', '.', '@', '!', '§', '%', '&', '?' }, 4);

den Button so zu erzeugen

this.Controls.Add(new HandyButton(textBox1, new Point(xOffset + 2, yOffset + 2), new char[] { '1', '-', '.', '@', '!', '§', '%', '&', '?' }, 4));

?

zu 2:
Hast Du recht - werde mich diesbezüglich dem Standard anpassen

zu 3:
Sehr gute Idee!

zu 4:
Also bei mir gibt die Berechnung schon eine Gleitkommazahl zurück

zu 5:
Stimmt, wird nachgeholt

zu Deinem Fazit:
Vielen Dank - soetwas baut auf und motiviert 🙂

Könntest Du noch etwas zu dem Einsatz des Interfaces sagen?
Ist es sinnvoll, das so umzusetzen, oder gibt es bessere Ansätze?

(Ziel ist, zu garantieren, dass die Form, das Panel, oder wo immer auch der HandyButton drauf liegt, die Möglichkeit bietet, den Eingabemodus festzulegen.)

Besonders interessieren würde mich, ob es eine bessere Möglichkeit gibt als das Interface, sicherzustellen, dass das Parent-Control eine Möglichkeit bietet, den Eingabemodus zu ändern und zurückzugeben.

Hallo,

schon mal auf der F#-Homepage geschaut?
In den FAQ wird ein bissel was zu den Zielen und der Motivation geschrieben.

Hallo,

habe das Ganze mal JustForFun in einer Klasse verpackt.

Bei Interesse: hier

Hallo zusammen,

dieser Beitrag hat mich motiviert, eine HandyButton-Klasse zu schreiben.

Jeder, der ein Handy besitzt und schon einmal eine SMS damit geschrieben hat, kennt sicherlich die Mehrfachfunktion der einzelnen Tasten.

Je nach Modus und Handytyp, wird beim Druck auf eine Taste eine bestimmte Funktion ausgeführt.
Beim wählen einer Telefonnummer wird bspw. die 'Hauptfunktion' der Taste ausgeführt, nämlich das Setzen einer Zahl.

Schreibt man eine SMS, so wird die 'Nebenfunktion' der Taste ausgeführt, nämlich das Setzen eines Buchstabens oder Zeichens, wobei jeder Taste mehrere Buchstaben oder Zeichen zugeordnet sein können. Durch mehrfaches klicken einer Taste kann man so über sämtliche ihrer Funktionen iterieren.

Im Anhang befindet sich der Sourcecode der Klasse, sowie eine Beispielanwendung in Form einer vorgefertigten Handytastatur, ebenfalls inklusive SourceCode.

Das Ganze ist JustForFun entstanden, da ich es für mich als nettes Thema zur Einarbeitung in C# angesehen habe.

Wenn Ihr Lust hab, könnt Ihr die Klasse erweitern, verändern, oder was auch immer.

Über Feedback bin ich natürlich sehr dankbar (es hilft mir beim Lernen!)

Danke.

Noch eine kurze Erläuterung:
So ein Handybutton wird zur Laufzeit erzeugt. Im Konstruktor werden die dem Button zugeordneten Zeichen in Form eines Char-Arrays übergeben.
Das erste Element dieses Array wird als 'Hauptzeichen' angesehen,; vergleichbar zu den Zahlen auf der Handytastatur.
Die restlichen Elemente sind die 'Nebenzeichen'; sie werden etwas kleiner unter das 'Hauptzeichen' gezeichnet.

Desweiteren wird im Konstruktor ein Control angegeben, welches als Ziel für die Tastendrücke dienen soll; idealerweise eine Textbox.

Außerdem kann festgelegt werden, wieviele Zeichen auf einem Button sichtbar dargestellt werden sollen, unabhängig davon, wieviele Zeichen sich tatsächlich hinter dem Button befinden.

Es gibt zwei Eingabemodi: Zahlen und Text.

Die Containerklasse, auf der der Button erzeugt werden soll (Form, Panel...), muss das Interface IInputMode implementieren. Über die dazugehörige Eigenschaft 'InputMode' wird der entsprechende Eingabemodus abgefragt, der bspw. über RadioButtons auf dem Container festgelegt werden kann.

22

Es funktioniert wie erwartet, es wird nur nicht die Methode aufgerufen wo du denkst 🙂 Wenn du ein char Array übergibst wird Concat(Object) aufgerufen und nicht Concat(Object[]). Grund ist einfach das char[] nicht von object[] abgeleitet ist. Beide sind von Array abgeleitet, und char ist auch von object abgeleitet. Aber ein char Array ist praktisch auf der gleichen Ebene wie ein object Array. Außer der gemeinsamen Basisklasse Array haben die nichts gemeinsam.

Uiuiui, sowas muss man erstmal wissen; jetzt tu ich es - danke 🙂

[...]kommt auch genau das raus was du erwartet hast.

Jau, das hatte ich auch so gemacht. Da das Array allerdings an eine Methode übergeben wird, und ich das Ganze ausschließlich auf ein Char-Array beschränken wollte, was das leider nicht möglich.

String s = new String(yourCharArray);  

Ach herrje, wie doof 🙁

Danke Dir!

Nichtsdestotrotz verstehe ich nicht, wieso das mit der Concat-Methode nicht so funktioniert, wie erwartet 🤔

Hallo zusammen,

ich habe ein Char-Array mit den Elementen 'x', 'y' und 'z', welche ich konkatenieren und als String zurückgeben möchte.
Nun dachte ich mir, nehme ich dazu einfach die String.Concat-Methode.

Da 'Object' ja die Mutter aller Klassen ist, bin ich davon ausgegangen, dass ich die Überladung nehme kann, die ein Object-Array entgegennimmt.

Die Methode nimmt mein Char-Array auch brav entgegen, nur was ich erwartet habe, nämlich den String "xyz", bekomme ich nicht zurück, sondern "System.Char[]" 🙁

Das MSDN sagt

concatenate the objects together as a string. To do this, the ToString method in the objects is called

was aus meiner Sicht so viel heißt, dass die ToString()-Methode der Array-Elemente aufgerufen wird, und nicht die ToString() Methode des Arrays selber, was hier aber wohl doch passiert.

Was tun?

Hallo,

sieh bsp im Anhang.

darf ich fragen, was das für einen Sinn hat? (nicht böse gemeint, verstehe es nur nicht)
Soll das eine Art Timer-Reset sein?

            timer1.Enabled = false;
            timer1.Enabled = true;

ja da sieht man das er das vrom stretch geschrieben hat.

Heißt das nicht 'from scratch'?! 😉

Hallo,

ich weiß nicht, wie Dein Design aussieht, ob mit der Mouse gearbeitet werden kann etc.

ergänzend zu Punkt 4 könnte ich mir vorstellen die Fehlermeldung beim MouseOver über besagtem Control in einer StatusBar oder als Hint auszugeben.

Sollte das aus Deiner Sicht ebenfalls den WorkFlow stören, da man ja den Cursor über das Control bringen müsste, könnte man auch die Fehler aller Controls in einem mehrzeiligen Textfeld o.ä sammeln, welches sich automatisch einblendet, sobald Count > 0, und automatisch ausblendet, sobald Count = 0.

Edit:
Eingaben sind bei uns nur in Dialogen möglich. Plausibilisiert wird erst beim Schließen des Dialogs.

Hallo,

ich weiß nicht, warum Du es so kompliziert machst.

herbivore hat Dir doch schon die Musterlösung präsentiert...

Mir gehts ähnlich wie xxxprod.

Als ich hobbymässig anfing, mich mit der Materie 'Programmieren' (damals Delphi) zu beschäftigen, war das Ganze noch neu und spannend.
Man war stolz, erste Ergebnisse zu erzielen, und sie anderen zeigen zu können.
Zum damaligen Zeitpunkt hätte ich mich wahrscheinlich als ''süchtig' bezeichnet 😉

Als mein Hobby dann irgendwann zum Beruf wurde, und ich täglich im Büro vor der IDE saß, sank das Interesse, mich im privaten Bereich auch noch damit zu beschäftigen, rapide ab.

Nun bin ich dabei, mich ein wenig in C# einzuarbeiten, was das Thema auch im privaten Bereich wieder interessant macht.
So enthusiastisch wie damals, gehe ich die Sache nun aber dennoch nicht mehr an.

Ich habe das Projekt mal umgeschrieben.

Es läuft nun nicht mehr als VS-AddIn, sondern als eigenständige Anwendung.
Da keine Interaktion mit der IDE notwendig ist, lässt sich das Ganze auch gut standalone als externes Tool einbinden und wird so vielleicht auch für Express-Nutzer interessant.

(und es lässt sich so wesentlich einfacher debuggen 😄)

Vielleicht hat ja jemand Verwendung dafür.

Ach komm, sag uns den namen dass wir gaaanz doll neidisch sein können und du dich gut fühlst

Spar Dir Deinen Sarkasmus.

Finde ich ehrlich gesagt ein wenig affig. Ich wollte lediglich ein Beispiel bringen, das zeigt, dass man nicht zwingend mit mathematischer Heiligkeit gesegnet sein muss, um als Softwareentwickler Fuß fassen zu können, und dann wird man hier so vorgeführt.

Schade.

außerdem sagt der arbeitsort garnichts über die qualifikation eines einzelnen aus. es gibt in jder firma richtig gute und richtig schlechte entwickler.

Korrekt, allerdings wird sich ein schlechter Entwickler in einer Firma mit 8 angestellten Entwicklern nicht lange halten können, da es keine Möglichkeiten gibt, sich zu verstecken.

Also dass jede Firma das von sich behauptet, stelle ich jetzt mal als Spekulation dahin.

Aber - Zahlen lügen nicht. Das sollte ein Mathematiker doch eigentlich wissen, oder?
Und wenn selbst der Wettberwerb meine Aussage untermauert, dann sollte schon was dran sein...

Und auch wenn ich Dir den Namen des Unternehmens nennen würde - dann heißt es wahrscheinlich "Na das kann ja jeder sagen, dass er da und da arbeitet...".

Aber was solls - ich muss mich nicht vor irgendjemandem rechtfertigen.

btw.

Die Firma, in der ich angestellt bin, produziert branchenspezifische Software aus dem Finanzwesen und ist damit marktführend in Deutschland und dem europäischen Ausland.
Diese Argumente find ich ja immer fantastisch.
Melden sich mal bitte alle, auf die das auch zutrifft!
Ja danke... alle wieder Hände nach unten.

Was willst Du jetzt von mir?

Ist doch klar, dass jeder, der in der Softwareentwicklung tätig ist, und die Mathematik versteht, diese als unerlässlich ansieht und dieses auch nach außen propagiert.
Aus meiner Sicht ist das in 80% der Fälle einfach nur halbherzig/einäugig, oder wie auch immer man es ausdrücken will, dahergesagt (soll heißen: nicht jeder Zweig der Softwareentwicklung setzt Mathematik voraus).

Die restlichen 20% sind der verzweifelte Versuch, sich von der Masse etwas abzuheben. Denn heutzutage kann bekanntlich jeder 'programmieren' ( 😄), was vor 20 Jahren noch nicht in dem Umfang möglich war.

Um es nochmal auf den Punkt zu bringen: eine pauschale Aussage zu treffen ist schlicht und einfach nicht möglich.

Ich persönlich bin kein Mathegenie; mit den Grundlagen bin ich vertraut.
Mein BWL-Studium habe ich wegen mangelnder Mathematikkenntnisse und mangelndem Mathematikinteresse irgendwann an den Nagel gehängt.

Die Firma, in der ich angestellt bin, produziert branchenspezifische Software aus dem Finanzwesen und ist damit marktführend in Deutschland und dem europäischen Ausland.

[...]

Dam kann ich nur zustimmen!

Eine Pauschalaussage wie "Wer kein Mathe kann, der wird in der Informatik, oder im Speziellen, als Programmierer, keinen Fuß fassen" ist absoluter Schwachsinn!

Klar macht es das Wissen um die Mathematik u.U. manchmal leichter; zur Not kann man aber auch alles nachlesen.

*confused* ?(

Jau, jetzt hab ich auch gemerkt, dass Path.Combine() wohl doch **genau **das Richtige wäre 😉

Super 👍

Edit:
@Khalid: ja, das kommt daher, aber dort gab es schon eine fertige IncludeTrailingBackslash-Funktion 😉

Ich glaube, dass ich noch viel zu kompliziert denke.
Es ist doch recht schwer, mich daran zu gewöhnen, dass all das was ich unter Delphi noch selber machen musste, in C# in irgendwelchen Klassen versteckt ist; und das dann auch noch zu finden X(

Path.DirectorySeparatorChar und EndsWith() waren gute Stichworte - vielen Dank dafür an Xqgene und markus.bodlos.

@markus.bodlos
Danke, aber ich finde das ohne den ❔-Operator wesentlich besser lesbar 😉

@herbivore
Ich hatte mir 'Path' angeschaut, nur nichts passendes gefunden.

Das mit dem (char))92 kommt noch aus Delphi-Zeiten - da ich ziemlich häufig irgendwelche Steuerzeichen 'darstellen' musste, war es sehr einfach, mal gerade #9 für TAB zu schreiben; habe das dann für alle anderen 'nicht-Buchstaben' und 'nicht-Zahlen' so übernommen.
Aber ich werde es mir abgewöhnen.

@tople
Danke, Combine() würde zwar auch funktionieren, wäre in diesem Fall aber nicht das richtige 😉

@all
Was ich mich allerdings frage: seid Ihr noch nie in die Situation gekommen, dass Ihr eine solche Funktion benötigt?
Nehmen wir einmal an, Ihr gebt dem Anwender die Möglichkeit, einen Dateipfad vorzugeben, in dem irgendwelche Output landen soll.
Was tut Ihr, um sicherzustellen, dass am Ende des Pfades auch der Backslash steht?

		public static string IncludeTrailingBackslash(string path)
		{
			if (!path.EndsWith(Path.DirectorySeparatorChar.ToString()))
			{
				return path + Path.DirectorySeparatorChar;
			}
			else
			{
				return path;
			}
		}

Hallo zusammen,

habe nach einer Funktion gesucht, die mir einen Pfad zurückgibt, der mit einem Backslash abschließt, falls dieser nicht vorhanden ist.

Da ich nichts gefunden habe, habe ich eine eigene Funktion geschrieben.

Meine Frage nun: habe ich etwas (bereits fertiges) übersehen, und wenn nicht, was kann ich an meiner Funktion verbessern?

		public static string IncludeTrailingBackslash(string path)
		{
			if (path[path.Length - 1] != (char)92)
			{
				return path + (char)92;
			}
			else
			{
				return path;
			}
		}

Ich fahre einen Citroen C1.

Sparsam im Verbrauch und für den Weg zur Arbeit genügts vollkommen.

Per Auto: 15 min
Per Bus/Bahn: 1 Std.

Das mit ÖV habe ich 2 Jahre lang mitgemacht.
Wenn man jeden Tag zwei Stunden alleine für die Hin- und Rückfahrt zur Arbeit verschwendet, dann überlegt man sich schon, monatlich für die Finanzierung und Unterhaltung eines Autos ne Menge Geld auszugeben.

🤔

20 als byte in Hex ist 14 und das erhälst Du mit Convert.ToString(20, 16).

0x14h ist kein byte.

Hallo,

zu Deinem ersten Problem könntest Du eine kleine Funktion schreiben:

		public string ToHex(int decimalValue)
		{
			return String.Format("0x{0}h", Convert.ToString(decimalValue, 16));
		}

Auch wenn ich nach herbivores Hinweis, doch die Doku zu benutzen, ehrlich gesagt etwas - auf gut deutsch "angepisst" - war, da ich die Suche ja nun wirklich benutzt, aber nichts gefunden habe, bin ich letztendlich froh, mit dem von ihm genannten Stichwort 'Schnittstelle' nochmal in der MSDN nachzusehen.

Ich habe nach "explizit" und "implizit" gesucht - aber auf "Schnittstelle" bin ich natürlich nicht gekommen 🙁

Jetzt wird mir auch der Sinn klar!

Danke an herbivore für das Öffnen der Augen.
Danke an JAck30lena für die konkreten Beispiele.

Vielen Dank an alle anderen für die Hilfe.

(Ich sage ja - bei mir dauert immer alles etwas länger X()

Okay, vielen Dank dafür.
Jetzt kenne ich wenigstens schonmal den Unterschied in der Notation 🙂

Aber wie wirkt sich dieser Unterschied aus? Bzw. was für ein tieferer Sinn steckt dahinter?

Das einzige, das mir auffällt, ist,

explizit exp = new explizit();
exp.foo();

dass ich hier exp.foo() nicht aufrufen kann.

Ist das der einzige Unterschied?
Bzw. ist der Sinn, auf diese Art eine Methode, die vom Interface übernommen werden muss, zwar zu implementieren, aber nicht aufrufbar zu machen?

@Golo

Implementiere die generische Version implizit und die nicht-generische explizit, und rufe die generische aus der nicht-generischen auf

Das sagst Du so in Deinem jugendlichen Leichtsinn 😉

Ehrlich gesagt kann ich mit der Begriffsabgrenzung implizit/explizit im Zusammenhang mit der Implementierung nichts anfangen 🙁

Implizite/explizite Typumwandlung -> das sagt mir etwas.

Aber wo ist der Unterschied, ob ich etwas implizit oder explizit implementiere?

Habe schon hier im Forum gesucht - überall explizit/implizit hier und da - aber nichts, was mir weiterhilft.
Auch im openbook und der MSDN finde ich ausschließlich Beispiele zur Typkonvertierung.

Guten Morgen Rainer,

Ich möchte Dir nicht zu nahe treten

Du trittst mir nicht zu nahe, da

Es dürfte Dir als Delphi-Entwickler bekannt sein, dass die Elemente(=Items bzw Strings) einer TStringList durchaus auch direkt mit meineStringList[5] ansprechbar sind 😉

...mir das sehr wohl bekannt ist 😉

Vielleicht habe ich mich in dem Satz

was ich erreichen wollte, war ein Pendant zu der Klasse TStringlist, welche es in Delphi gibt...Dort werden die Strings halt per TStringlist.Strings_ angesprochen.
etwas undeutlich ausgedrückt.
Oder sagen wir mal so: ich habe versucht, mein Anliegen für die C#-Gemeinde so einfach wie möglich zu gestalten; was aber wohl daneben gegangen ist (Vielleicht sollte ich den Gedanken verwerfen, dass sich hier ausschließlich C#-Entwickler rumtreiben).

Ich bin davon ausgegangen, dass genau solche Nachfragen (aber wenn das doch da auch geht, wieso willst Du es dann hier anders haben...) kommen werden, wenn ich ins Detail gehe.
Denn ich glaube, meine Intention ist noch immer nicht ganz klar geworden.

Es geht mir hier nicht darum, eine TStringlist-Adaption für C# zu erstellen (soetwas gibt es glaube ich sogar schon).
Sondern nur darum, die Möglichkeiten kennenzulernen, die ich in C# habe.

Speziell in diesem Fall geht es mir ausschließlich darum, zu wissen, ob sich ein Indexer, der von der Basisklasse geerbt wird, ausgeblendet werden kann.

Der Fall mit der TStringlist war nur ein Beispiel, das eine Anwendungsmöglichkeit darstellen sollte.

So, ich hoffe nun alle Unklarheiten beseitigt zu haben 😉

Okay, vielen Dank!

Ich werde mir das Thema morgen wieder zu Gemüte führen.

Das sollte nichts gegen Dich sein!

Es ist nur so. dass ich das Ganze noch nicht richtig erfasst/verstanden habe.
Ich beschäftige mich noch nicht so lange mit C#.

Bin zwar hauptberuflich Softwareentwickler, allerdings entwickeln wir unter Delphi.
Und da gibt es bspw. keine Generics, und mit Interfaces wird da auch nicht so viel gearbeitet, so dass ich mich da erstmal komplett neu reindenken muss.

Dauert bei mir halt immer etwas länger, bis es 'klick' macht 🙁

@herbivore
Ich habe doch geschrieben:

Vergiss das Ganze - ich hatte System.Collections nicht eingebunden... und da bringt der so eine kryptische Meldung - tse

Hatte es also schon gemerkt; nur etwas später, da ich mich noch nicht so lange mit der Thematik beschäftige, wie Du.
Und so eindeutig, wie Du es beschreibst, finde ich die Fehlermeldung nicht.

DIese klingt nach 'Da fehlt irgendein Argument' was aber nicht zutreffend ist. Dass der Compiler etwas anderes meint, da er etwas nicht kennt, kann ich nicht wissen - ich denke mal, dass soetwas die Erfahrung mit sich bringt, die ich einfach noch nicht habe.

Trotzdem danke für den Link.

@Golo
Darüber muss ich erstmal nachdenken 😉

Bei Deinem Beispiel meckert er übrigens beim Compilieren bei der Implementierung der nicht generischen IEnumerable, es sei das erste Typargument erforderlich; was immer das auch bedeuten mag.
ich nehme an du meinst jetzt mein beispiel:
komisch. bei mir kompiliert er ohne zu meckern.... gibt nicht mal ein warning..

Da ich dabei war, Dich zu zitieren; ja 😉

Das ist der Block, den er anmeckert:

        IEnumerator IEnumerable.GetEnumerator()
        {
            return ((IEnumerator)m_wrappedList);
        }

Edit: Screenshot angefügt
Edit2:
Vergiss das Ganze - ich hatte System.Collections nicht eingebunden... und da bringt der so eine kryptische Meldung - tse 😉

halte dich lieber an den standard von microsoft, sonst wirst du oft verflucht werden.

Damit meinst Du, ich soll es belassen, wie es ist, und auf myList[5] zugreifen, und nicht auf MyList.Strings[5], korrekt?

Bei Deinem Beispiel meckert er übrigens beim Compilieren bei der Implementierung der nicht generischen IEnumerable, es sei das erste Typargument erforderlich; was immer das auch bedeuten mag.
Aber wenn ich es eh nicht nutzen soll... (interessieren würde es mich trotzdem =))

von List<T> abzuleiten, ist nach JuyJukas Ansicht - die wir alle teilen - aussichstlos für dein Problem (und auch sonst ist List<T> selten die richtige Oberklasse).

Wie gesagt, die Aussage habe ich einfach falsch interpretiert.

@kleines_eichhoernchen
Danke 😉

public class Stringlist : List<string>  
  

damit kommst du aber nciht weit, da du dann immernoch über den indexer darauf zugreifen kannst.

Das hattet Ihr ja schon geschrieben.
Nur hörte sich die Aussage von JuyJuka so an, als wenn eine Ableitung von List<string> grundsätzlich nicht möglich sei.
Aber das habe ich wohl falsch interpretiert.

Den Code werde ich mir mal zu Gemüte führen - vielen Dank dafür 🙂

Hallo und danke für Eure Antworten,

was ich erreichen wollte, war ein Pendant zu der Klasse TStringlist, welche es in Delphi gibt.
Dort werden die Strings halt per TStringlist.Strings_ angesprochen.

Ob ich persönlich MyList_ oder MyList.Strings_ verwende, ist eigentlich gehupft wie gesprungen.
Es ging mir hier eher generell um die Frage, ob ich einen Indexer der Basisklasse 'ausblenden' kann.

Den Leitspruch
das Grundprinzip ist: Vererbung bedeutet immer Erweiterung. Vorhandenes bekommt man durch Vererbung nicht weg.
sollte ich mir merken.

@JuyJuka
Was meinst Du mit

Ableiten von List<string> ist aussichtslos

?

Also das Ableiten ansich hat schon funktioniert.

	public class Stringlist : List<string>
	{
        }

Hallo zusammen,

mein Ziel:

Eine Klasse, abgeleitet von List<string>, mit einer Eigenschaft Strings vom Typ string, welche die Elemente der Liste indiziert.
Auf Strings soll also per Indexer zugegriffen werden können. MyList.Strings[5] soll also das vierte Element aus der Klasse zurückgeben.

Gleichzeitig soll es aber nicht mehr möglich sein, auf die Elemente der Liste per Indexer zugreifen zu können. MyList[5] soll also nicht mehr aufrufbar sein.

Lässt sich dieses realisieren?

ColorConverter kenne ich, dass ist aber nicht meine Wissenslücke.

Dann solltest Du Deine Frage auch dementsprechend stellen. Bei

Jetzt meine Frage wie und wo kann ich den Datentyp umwandeln?

sollte klar sein, dass Du eine der ersten beiden Antworten bekommst.

Hallo,

schonmal mit der Klasse 'ColorConverter' probiert?