Hallo burli,

ich kann diesen "aufhänger" an der Performance nicht ganz nachvollziehen.
Wo genau liegt das Problem in den ms unterschied?

Hallo Stipo,

wenn du ein Interface erweiterst nachdem es bereits eingesetzt wird, stellt diese Erweiterung ein "Breaking Change" dar.
Warum?
Jeglicher Code der dieses Interface implementiert und neu compiliert wird funktioniert nicht mehr. Da eine Interface Implementierung ja vorschreibt das alle Methoden/Eigenschaften usw. implementiert sind.

Gruß
Stefan

Hallo zerberos,

hier solltest du fündig werden um die richtige Ausgabe zu erhalten.
MSDN - DateTime

Hallo manullino,

Was ist denn die Basisklasse von BaseClass<T>?

public BaseClass(string name) : base() {
    Name = name;
}

Du solltest das ": base()" durch ": this()" ersetzen.
Du möchtest ja schließlich den Standard-Konstruktur DIESER Instanz aufrufen und nicht der Basisklasse.

edit:
Da fällt mir gerade ein (hoffentlich Irre ich micht nicht), es ist kein guter Stil einen public Konstruktor in einer Abstrakten Klasse zu definieren.
Wer soll diesen jemals aufrufen können, damit er public sein sollte? Mach ihn lieber protected.

Hallo Consales,

ich wage mich mal auf dünnes und versuche ein Beispiel.
Kurze Erklärung ein Char ist immer nur genau ein Zeichen.
Also 'A' (Hier sind die ' wichtig, da damit der Compiler (zumindest VS) erkennt, das es sich um ein Char handelt).

string text = "Das hier ist ein Text der E's und A's enthält.";
int counterA, counterB;
counterA = counterB = 0;
for( i = 0; i < text.Length-1; i++){
    if( char.ToLower(text[i]) == 'a' ){
        counterA++;
    } else if ( char.ToLower(text[i]) == 'e' ){
        counterB++;
    }
}

Hallo M.Holder,

wieso hattest du mit IndexOf kein Erfolg?
Vielleicht Groß- und Kleinschreibung nicht berücksichtigt?

Ansonsten würde mir nur noch string.Split() einfallen. Dann hast du aber N-Dimensionen im Ergebnis Arrays, wenn das Wort nochmal in einem Wort oder als eigenes Wort vorkommt. (Gleiches Problem dürfte aber auch bei IndexOf auftreten außer du nimmst ' ' (Leerzeichen) explizit mit auf).

Ansonsten gibt es wahrscheinlich für sowas auch einen RegEx-Ausdruck.

Gruß
Stefan

Hallo Lector,

das liegt daran, dass List<T> IList explizit implementiert.

Also wie folgt:

List<T> : IList, .... { // weitere Implementierungen
bool IList.Contains(object value) {
    // Implementierung
}

Daher siehst du bei der Verwendung von List<T> nicht direkt die untypisierte Methode.
Du kannst aber naürlich jetzt folgendes machen:

IList tmpList = new List<string>();
tmpList.Contains(); // Hier würde nun die untypisierte Methode angesprochen werden

Gruß
Stefan

Hallo Consales,

du machst es dir ein wenig schwer....

Ein string ist nichts anderes als ein Array von Chars. Daher kannst du auch durch einen string per for-schleife gehen. Du solltest bei deinem Vergleich natürlich noch auf Groß- und Kleinschreibung achten.

string text = "Das hier ist ein Text";
Console.Write(text[2]); // Hiermit würde ich das Zeichen 's' ausgeben.

Hallo Consales,

die Länge eines Textes kannst du über die "Lenght" Eigenschaft rauskriegen.
Beispiel:

txtFoo.Text.Length

Oder bei einer Variable

string foo = string.Empty;
int bar;
foo = "Länge6";
bar = foo.Length;
// bar = 6

Aber das ganze lässt sich höchstwahrscheinlich mit einem einzeiligen RegEx-Ausdruck lösen. Nur leider bin ich da nicht fit drin.

Gruß
Stefan

Hallo Jürgen,

kein Problem.
Habs mir schon heruntergeladen und werd es mir jetzt mal ansehen.

Danke vielmals!

Gruß
Stefan O.

Hallo Peter,

danke, aber ich meinte nicht LightCore 😃

Ich meinte den Beispiel Code (und Präsentationsfolien sofern es welche gibt) den Jürgen beim Vortrag erstellen wollte (oder wurde mein erster Post schon missverstanden?).

Außer natürlich es sind keine "neuen" dann kann man dieses Posting ignorieren.

Gruß
Stefan

*Thread auskram*

Hallo zusammen,

ich wollte nochmal nachfragen wo es den Quellcode zum Download gibt.

Viele Grüße
Stefan O.

Hallo herbivore,

da hast du natürlich Recht.

Ich müsste aber auch einfluss darauf haben, welcher Planet hinzugefügt werden soll.
Sprich es dürfen keine doppelten Einträge vorhanden sein.

[Edit]
Mir geht es aber jetzt eher darum ob man das ganze so Designen sollte.
Und ob die Klassen, welche auf die Tabellen gemappt sind, überhaupt weitergehende Logik besitzen sollten.

Hallo zusammen,

ich versuche gerade mit NHibernate ein kleines Projekt umzusetzen.
Leider scheitere ich schon beim erstellen der Objekte für das Datenbank mapping.

Vielleicht könnt ihr mir ja helfen.

Problem:
Es gibt 2 Tabellen.

Player

• Id
• Name
• Punkte
• Allianz
• ...

Planet

• Id
• PlayerId
• Name
• Coordinaten

Jeder Player kann 0 - n Planeten besitzen

1. Erstellt man Objekte die die Tabelle 1:1 abbilden?
2. Ich hatte mir meine Objekte bisher so vorgestellt

public class Player {
	// Name, Punkte, Allianz usw.
	public ICollection<Planet> Planets { get; private set; }
}

public class Planet {
	// Name,..
	public Coordinate Coordinates { get; private set; }
}

public class Coordinate {
    // Koordinaten,..
}

Für diese Klassen würde ich dann entsprechend die mappings erstellen.
Ich bin mir nur nicht sicher ob das so korrekt ist.
Eigentlich müsste ich ja jetzt dem Player Operationen zur Verfügung stellen womit man einen Planet hinzufügen bzw entfernen kann.
Aber hat die Playerklasse dann nicht zu "viel" Logik in sich vereint?

Gruß
Stefan

Hallo Jürgen,

leider ist Konstanz-Kreuzlingen - von mir ausgesehen - relativ weit weg.
Daher wollte ich fragen ob der Code und die Präsentationsfolien im Anschluß an die Veranstaltung online zur Verfügung gestellt werden können.

Da ich mich selbst ein wenig mti LightCore beschäftige, aber höchst wahrscheinlich noch gar nicht alle möglichkeiten erfasst habe, wäre es wahrscheinlich hilfreich sowas an Beispielen zu sehen.

Da wäre nämlich schon die Frage ob man per XML-Konfigurationsdatei Cunstructor Injection machen kann.

Schönen Tag noch
Stefan O.

Hallo herbivore,

Danke für die Antwort.

Ich bin mir zwar noch nicht sicher, ob ich es richtig verstanden habe ?(, aber ich werde mal darüber nachdenken und mich ggfls nochmal melden.

Gruß
Stefan

Hallo herbivore,

dann verstehe ich dich falsch und kann es auch nicht nachvollziehen.

In deinem Beispiel hast du die "neue" Eigenschaft in die Klasse gelegt, welche die Briefadresse aufbereiten soll.

Ich möchte die neue Eigenschaft in den Datencontainer aufnehmen.

Hallo herbivore,

ich glaube du hast da etwas missverstanden. Ich hatte eher im Sinn das ganze ca so aufzubauen:

public class Address{
    public string FirstName { ... }
    public string LastName { ... }
    // weitere Eigenschaften
}

public interface IPostalAddress {
    string GeneratePostalAddress(Address address);
}

public class PostalAddress : IPostalAddress {
    public string GeneratePostalAddress(Address address){
        // Implementierung der Briefadressgenerierung
    }
}

Dies wäre die "Standard"-Implementierung.

Nun bekommt ein Kunde aber eine neue Eigenschaft.

public class CustomerXAddress : Address {
    public string Department { ... }
}

Wie sollte man nun vorgehen um die Eigenschaft Deparment auch in der Briefadresse zu bekommen. Neue Ableitung? Anpassng des Kontraktes?
Irgendwie stehe ich da auf dem Schlauch 😕

Ps: Ich bin mir nicht sicher ob das schon zum Strategypattern gehört, aber auf jedenfall bin ich bestrebt einer Klasse nur eine Aufgabe zu geben.

Hallo herbivore,

ist es in einem solchen Falle denn gewollt einen cast auszuführen? Anders komme ich ja nicht an die Eigenschaft der Unterklasse nicht dran.

Hallo Florian,

das Strategy- und Builder-Pattern sind mir bekannt. Doch leider wüsste ich jetzt nicht wie ich es darauf anwenden würde. Mir geht es ja im konkreten nur darum, wie ich die Behandlung des neuen Address-Typen richtig bewerkstelligen würde. Da ein explizites umcasten/auf Typ prüfen nicht der richtige Weg sein kann.

Hallo herbivore,

danke erstmal für die Beantwortung der Fragen.

Was meine Frage angeht, habe ich glaube ich einen Gedankensprung gemacht, weshalb das nicht direkt im Kontext steht.
Es geht im speziellen um Contract First Design und Komponenten.

Ich versuche es mal mit einem anderen Beispiel, was hoffentlich besser passt.
Wenn ich eine Komponente entwickel, welche anhand eines Adressobjektes eine Briefadresse erzeugen soll, sähe das ganze ungefähr so aus:

Kontrakt:

public interface IPostalAddress {
	string GeneratePostalAddress(Address address);
}

Dazu gibt es jetzt eine Implementierung und eine Definition des Address-Typens.

Jetzt aber der Punkt an dem ich mich derzeit ein wenig "aufhänge".
Diese Struktur ist bei X Kunden im Einsatz. Kunde Y aber erhält einen neuen Wert der auch in der Briefadresse berücksichtigt werden soll.
Dementsprechend würde ich für Kunde Y eine Ableitung von Address machen und von nun an mit dieser arbeiten.
Wie aber würde ich nun vorgehen um dieses Feld in der Briefadresse anzuzeigen?
IPostalAddress um eine Methode erweitern, welche den neuen Typen entgegen nimmt?
Einen neuen Kontrakt erstellen, der mit diesem neuen Typen umgehen kann?

Anforderungen ändern sich, das weiß jeder. Aber wie behandel ich solche Anforderungen, wenn ich mit einer "Standardsoftware" beginne und diese Individualisierbar halten muss?

Hallo liebe Community,

im Zuge der Verwendung von LightCore habe ich mich mit den Themen DI, IoCC, SL/MK, der Komponentenorientierten Architektur (KOA) und dem Contract First Design(CFD) beschäftigt.

Alles in allem glaube ich die einzelnen Sachen prinzipiell Verstanden zu haben.
Doch stellen sich mir noch immer ein paar, auch grundlegende Fragen, zu diesen Themen.

1. Wo genau "hilft" mir diese Entkopplung mit einer Schnittstelle (Interface) statt einem Typen zu arbeiten?
2. Wo zieht man eine Grenze zwischen "Das hier ist eine Komponente" und "Das hier ist Framework"? Meiner bisherigen Ansicht nach muss man dies Unterscheiden, weil man ja dann absolut unterschiedlich damit umgeht.

Frage für den Einsatz von Schnittstellen.
Ich habe eine Adressverwaltung mit Stammdaten (Name, Vorname, usw.) welche ich über ein Objekt "Adresse" darstelle.
Wenn ich nun eine Komponente habe, die ein solches Adressobjekt speichern soll ist dies ja simpel. Die Komponente nimmt das Objekt entgegen und persistert es irgendwie.
Wie verfahre ich aber, wenn ich dieses Modell bei 10 Kunden haben und der 11te Kunde erhält ein weiteres Feld.
Sollte ich dann extra für diesen Kunden eine eigene neue Klasse Adresse schreiben und die Persistenzschnittstelle entsprechend anpassen?
Falls ja, ist das praktikabel?

Ich hoffe es ist verständlich worauf ich hinaus möchte.
Falls nicht, bitte sagen und ich versuche das ganze besser verständlich zu machen.

Gruß
Stefan