Du solltest erst mal Benchmarken, wo die Performance Lücke auftritt.
Vielleicht geht es schneller, wenn du die Elemente in einem Pool verwaltest oder bei der erstmaligen Benutzung cached.
Da sollte man aber auf jeden Fall das Speicherverhalten zur Laufzeit beobachten

Das ist eine einfache XML Datei, mit jedem Text Editor (vorzugsweise mit XML Highlighting) kann man die Datei editieren

Hallo,

danke für die Tipps. Das Template Hacking war wirklich nur ein Hack, um zu gucken, ob das so geht, dass es kein gutes Design ist, war mir klar 😃

Die Tipps sind jedoch gut, ich hab im Moment dafür einen spezialisierten Event Manager, aber es hindert mich nichts, über Komposition die Abarbeitung der Events von Subkomponenten zu erledigen.

Danke!

Hallo,

ich refaktorisiere eine Anwendung, in der eine Reihe von Events mit nahezu gleichen Delegaten abgearbeitet werden.
Das sieht dann irgendwie so aus:

public Action<T1> event1;
public Action<T1> event2;
...

// Die hander
public void Event1Handler(T1 t)
{
  var relevant = "string_a";
  // mach was 
}

public void Event2Handler(T1 t)
{
  var relevant = "string_b";
  // mach was 
}

Die Handler machen alle das gleiche, der einzige Unterschied ist der "relevant" string, der immer unterschiedlich ist.

Man könnte die Handler wunderbar zu

public void EventHandler(T1 t, string a)
{
  var relevant = a;
  // mach was 
}

generalisieren, nur stimmt dann natürlich die Signatur nicht mehr mit dem Event überein, auf welches ich lauschen will.

Die Event Seite ist in so fern jedoch geschlossen, dass ich die Event Signatur an der Stelle nicht ändern kann.

Gibt es eine Möglichkeit, die Handlerseite generischer zu gestalten, ohne die Event Seite zu ändern?

Mit wildem C++ Hacking würde man es mit Templates lösen können, aber das wäre so dirty, dass ich es nicht mehr Refactoring nennen kann:

      public class T1
      {
         public string str = "aaaa";
      }

      public class T2 : T1
      {
         public new string str = "bbbb";
      }

      public void EventHandler<T>(bool enabled) where T : T1, new()
      {
         var relevant = new T().str; 
      }

 //////
event1 += EventHandler<T1>;
event2 += EventHandler<T2>;

Über bessere Ideen wäre ich dankbar 😃

Klingt jetzt blöd, aber einfach mal im Debugger durch steppen und gucken was passiert.

Benötigst du auch leere Verzeichnisse, in denen kein .svn drin ist? Wenn nein, dann wäre http://msdn.microsoft.com/de-de/library/system.io.directory.createdirectory.aspx ja ideal, weil es die Hierarchie erstellt.
Du erzeugst einfach alle Verzeichnisse und movest die .svn dann.

Das Addon ist bei dir aber nicht TortoiseSVN, oder? 😃

Weil er dann eine Methode braucht, die mehrere Verzeichnisse eines Pfads erstellen muss.
Die
> erstellt doch sämtliche Ordner des übergebenen Pfades. Wenn es kein Verzeichnis "D:/A" gibt, erstellt ein einfaches Directory.CreateDirectory("D:/A/B/C/D/E/D/G/H/I"); die komplette Hierarchie.

Oh, hatte ich nicht aufm Schirm, wieder was gelernt.

@1mannlan: du hast noch nichts zu der Performance gesagt

Pack dir als einfacher test einfach bevor du etwas von a nach b kopierst ein
Debug.Assert(Directory.Exists("von"));
Debug.Assert(Directory.Exists("nach"));

rein, dann wirst du merken, ob das Problem daher kommt

Bau dir im ersten Durchlauf eine Liste der Verzeichnisse, die du moven willst und reproduziere dabei die Ordner-Struktur.

Der zweite Schritt moved dann die Ordner

Edit: BhaaL: Weil er dann eine Methode braucht, die mehrere Verzeichnisse eines Pfads erstellen muss.

In welchem Kontext soll das ablaufen? Das scheint mir künstlich ein wenig zu abstrahiert worden sein. Was soll der Anwendungszweck sein?

Eine Beschreibung der Ebene durch drei Rotationen finde ich auch komisch.

Die Theorie hat MrSparkle beschrieben, du brauchst eine Affine Transformation des Koordinatensystems der Welt in das lokale der Ebene.

Wie viel wissen verfügst du bei der Thematik?

Prinzipiell geht es über Remote Desktop.
Aber dann wird der Benutzer auf dem Zielrechner abgemeldet, sprich keine DVD gucken,
daher geht das in der Konfiguration nicht. Ohne DVD gucken wäre es kein Problem

Alles klar.

Vielen Dank für die Erklärung

Hallo,

jetzt sehe ich es.

Ich hab es nun so gelöst, dass ich eine eigene Klasse habe:

[Serializable]
   public class LocalizableDescriptionAttribute : System.ComponentModel.DescriptionAttribute
   {
      public LocalizableDescriptionAttribute(string resourceKey)
         : base(EditorPlugin.ResourceManager.GetString(resourceKey))
      { }

   }

Mein EditorPlugin hat nun eine statische Instanz auf den ResourceManager.

Ist das so die Art, wie du es gemeint hast? Oder gibt es einen Weg, wo man ein eigenes Attribut sparen kann?

Vielen Dank

Hallo,

ich habe zwei Resourcen Dateien für die Default Culture und für Deutsch eingerichtet. Die eine heißt Strings.resx und die andere Strings.de.resx, bei beiden steht bei Build Action "Embedded Resources".

Was mich hierbei enorm verwundert ist die Tatsache, dass die Strings.de.resx als eigene Assembly gebaut wird. Ich hab in der Doku nach geguckt, was der Unterschied zwischen Build Action "Embedded Resource" und "Resource" ist und die extra DLL eigentlich bei "Resource" erwartet.

Das Problem, worauf ich eigentlich hinaus will: Es wird für die Strings.de.resx eine eigene Projekt.resources.dll gebaut und passend angezogen. Das ist ok so, aber mich wundert es, dass diese immer im Release gebaut wird.

Das System, in dem wir arbeiten, meckert ständig, dass unsere Assemblies gemischt werden, wenn wir bei der Entwicklung die restlichen DLLs im Debug vorliegen haben.

Diese Resource DLL übernimmt neben dem Build Typ auch die Assembly Info des Projekts, in dem sie sich befindet, nicht.
Da diese Resource kein eigenständiges Projekt ist, ist mir nicht klar, wieso diese eine eigene Assembly Version und den falschen Build Typ bekommt.

Für ein paar Tipps wär ich dankbar.

Danke

Hallo,

gucke mir grade den button an, aber ich sehe dort keine Resource oder DescriptionAttribute

Hallo,

ich bastele an einem Mehrsprachen-Support für meine Anwendung und bin auf ein Problem gestoßen.

Eine Klasse wird über das PropertyGrid dem Benutzer zum editieren gegeben. Die Felder haben alle ein DescriptionAttribute, welches die Felder beschreibt.

Ich habe jetzt aber in der MSDN nichts darüber finden können, wie man das Attribut extrahiert.
Ich kann zwar das Attribute als const string extrahieren,à la

private const string _myVar = "Was auch immer";
[DescriptionAttribute(_myVar),
...

aber ich finde keine Möglichkeit, den String aus eine Resource zu bekommen, da diese zur Compile-Zeit nicht const ist.

Wenn einer einen Tipp diesbezüglich hat, wäre ich sehr dankbar.

Danke

Bezüglich welcher Softwareergonomie? Generell oder unsere?

Die Comboboxen sind eine Notwendigkeit um ein komplexes System einzustellen. (Ich will hier Komplex nicht als Ausrede für schlechte Usability vorschieben)

Ich hab auch schon überlegt, nur die Reiter zu synchronisieren, aber ich bin unsicher, ob der folgende Aufwand es wert wäre.

Naja, es werden mehr. Insgesamt über Registerreiter einige hundert Stück.
Das ist ein generischer Dialog, da ich die Daten nur geliefert bekomme und diese aktualisieren muss.

An der Stelle bin ich nur das Frontend.

Mich wundert beim Timing, dass einige AddRanges ein Delta von 0, andere von 15 ms haben, aber die Summe stimmt immer ungefähr.

Wenn die Anwendung im Debugger läuft und gerade hängt. Kannst du in VS mal auf Pause drücken.
Wenn es klappt, landest du an der Stelle, wo er gerade hängt. Wenn diese nicht wirklich hilfreich ist, so könnte der Call Stack zumindest helfen

Hallo herbivore,
dein Post habe ich gar nicht mitbekommen.

Begin und EndUpdate hat leider nicht geholfen.

Durch ein paar Messungen habe ich festgestellt, dass ComboBox.Items.AddRange äußerst lange dauert.
Ein AddRange dauert bei mir im Schnitt 15 ms.
Die Signatur von AddRange hier ist

 public void AddRange(object[] items);

Da habe ich mich gefragt, ob eventuell das object[] da ein Problem ist. Wird hier geboxt und ge-unboxt, oder etwas ähnliches, was die Performance tötet?

15 ms für ein Array, dass aus 5 Elementen besteht finde ich recht happig.

Tja, was würd ich dafür geben, mal in den C# Source der Klassen gucken zu können 😃

Du erzeugst hier 2 Instanzen. Ist das so Absicht? Denn dein Code hat mit dem Vorhaben deines Eröffnungsposts nichts mehr zu tun.

Wo mach ich das? Ich sehe im Moment nicht, wo ich das tu

Was genau meinst du denn damit? MyBaseClass ist doch kein Interface. Und ein Interface hat keinen Konstruktur. Vielleicht solltest du das nochmal erklären. Bisher hast du immer nur gesagt, was nicht geht.

Was meinst du damit?
MyBaseClass ist kein Interface, das ist korrekt. Und da es kein Interface ist, hat es einen Konstruktor.

Ich hab nie von einem Interface geredet.

MyBaseClass kommt nicht von mir und ich hab keine Aktien darin

@JAck30lena, ich habs so mit Delegaten gelöst:

 public class MyBase
   {
      public MyBase(string n)
      {
         Console.WriteLine("Output "+n);
      }
   }

   public class Generic<T> where T: MyBase
   {
      private readonly Func<T> _del;
      public Generic(Func<T> del)
      {
         _del = del;
      }

      public void create()
      {
         var t = _del();
      }
   }

   class Program
   {
      static void Main(string[] args)
      {

         new Generic<MyBase>(() => new MyBase("string")).create();
      }
   }

Smou, nee, geht nicht, weil man keine Konstruktor so aufrufen kann, die nicht parameterlos sind.

MrSparkle, das sieht aber schon recht stark nach Reflection aus.

Dann sieht es wohl nach einem Delegaten aus

Edit: JAck30lena: Erst zur Laufzeit ist ein No-go an der Stelle

Ich hab eine Klasse MyBaseClass, welche nur einen Konstruktor mit einem string hat, keinen Parameterlosen

Jetzt wollt ich einen generischen Handler dafür bauen:

public GenericHandler<T>: where T : MyBaseClass
{
public void machwas()
{
  var t = new T("mein string");
}
}

Das Ergebnis ist die Compilermeldung da oben.

Warum kennt das T keinen Ctor mit einem String? Er ist in MyBaseClass definiert.
Und gibt es eine Möglichkeit, ein generic constraint mit einem Typen zu deklarieren?

Also so etwas:

public GenericHandler<T>: where T : MyBaseClass, new(string)

nur "new()" hilft mir an dieser Stelle ja auch nicht.

Ich kann das Interface von MyBaseClass nicht anpassen, weil es nicht von mir kommt.
Und es bietet auch keinen Parameterlosen ctor an

Edit: Reflection würd ich gerne vermeiden. Aber ich komme wahrscheinlich nicht um einen Delegaten, den ich im ctor mitgebe drum herum, oder?

Ich bin mir gerade nicht sicher, was passieren würde, wenn der User während des Updates die Dropdowns ändern.
Kriegt man so nicht einen ziemlich inkonsistenten Zustand?

Hallo,

ich hab ca. 40 Dropdowns, die bei bestimmten Events aktualisiert werden.

Die Dropdowns bekommen neue Werte und werden quasi resetet.

Das ist jedoch ziemlich langsam, das Update benötigt knapp eine Sekunde.

Kann man das Reseten der Dropdowns irgendwie am Stück machen und dann nur ein Update der GUI fahren?
Zuerst dachte ich da an SuspendLayout, ResumeLayout, aber das ist hier ja nicht das Problem.

Es gibt auch SelectedValueChanged auf den Dropdowns und der Code feuert viele davon, aber diese Methode wird sofort verlassen und dürfte nicht der Bottleneck sein.

Danke

Nein, wohl nicht.

Das Problem ist, dass ich im Endeffekt in einem Plugin einer GUI Anwendung bin, die Localizable auf False hat.

Ich werde mal sehen, wie ich die Ressourcen manuell switche. Das müsste dann gehen.

Oder meinst du damit etwas anderes?

Setzt aber voraus, dass jede Ressource redundant den Key hält, ist das korrekt?

So.
Bin jetzt erst dazu gekommen.
Das Tool scheint zwar nützlich zu sein, aber es Unterstützt nicht wirklich i18n, oder irre ich mich? Es extrahiert Strings und packt die als Ressource. Da habe ich aber immer noch keine Möglichkeit, diese für mehrere Sprachen zu definieren, oder?

Hallo,
das ist vielleicht eine dumme Frage, aber eine, auf die ich keine Antwort bekomme.

Ich hab eine Assembly bekomme, die eine AssemblyName.xml beinhaltet, was offensichtlich die XML Doc Tags des Codes in einer XML beinhaltet.

Kann VS 2008, wenn es eine Assembly einbindet, diese XML automatisch zu ordnen und bietet Methodendokumentation? Oder ist die XML nur dazu da, um mit anderen Tools weiter verarbeitet zu werden?

Hallo,

Mir ist noch etwas eingefallen, recht spät zwar, aber besser spät als nie:

Warum hilft es dann in einer Schleife eine temporäre Variable anzulegen, ihr das "s" zuzuweisen und dann zu benutzen?

Danke

Ich rede nicht vom SVN, das ist natürlich sowieso sauber. Aber wenn ich es ausgecheckt habe, will ich am Speicherort der Source keine anderen Dateien haben, die Visual Studio generiert. Ich rede nicht von SVN Ignore Regeln oder derartigem, ich will nur den Ort der Metadaten sinnvoll umlegen können. C++ und C++/CLR haben ja einen weit größeren Konfigurationsradius. Da kann man angeben, wohin die Intermediate Directories hin sollen. Das fehlt mir bei C# enorm.

Wir haben ein paar Schwierigkeiten unter VS 2008 einen Projekt so anzulegen, dass jegliche Generate von Visual Studio in ein anderes Verzeichnis gepackt werden, als die Source Location.

Zum Beispiel kriegen wie das obj Verzeichnis nicht gescheit verlegt und alle Meta Daten, die Visual Studio generiert, werden neben der Solution abgelegt.

Hat jemand schon mal geschafft den Source komplett sauber zu halten?

Der ist auch nicht in einer Form, er ist ein einer Plugin-Einsprungspunkt Klasse, die alle Ressourcen verwaltet

Hallo alle,
danke für die ausführliche Erklärung.

Es ist in der Tat so, dass das Property nicht teil der eigenen Klasse ist, sondern von einem Manager (scherz 😄)

Ich glaub mein Fehler lag darin, dass ich der vorkompilierten Sicht von Visual Studio vertraut habe. Das Property hatte ich auch erzeugt, bei der Initialisierung habe ich
"FormManager =" geschrieben und er hat mir das Property gehighlighted, als wäre es eine Klasse (also in den Standardeinstellungen blau dargestellt)
Da hab ich es nicht weiter versucht, weil es schon nach einem Fehler aussah.

Nun, dem wahr wohl nicht so 😃

this. hätte ich auch mal testen können.

Naja, nun weiß ich auf jeden Fall sicher, dass es geht und auch nicht ein Designfehler von mir wäre, wenn ich das mache 😃

Danke

Edit: Bezüglich des MSDN Ausschnitts: Bei mir beschreibt FormManager auch seine Funktion. Er instantiiert und verwaltet alle Dialog und Formen in der Anwendung.
Gibt es da einen treffenderen Namen?

Danke für die Aufklärung 😃

Hab es nun verstanden

Ich habe folgenden Code

using System;
using System.Collections.Generic;
using System.Linq;

namespace ConsoleApplication4
{
   class Program
   {
      static void Main(string[] args)
      {
         List<int> foo = new List<int>{10,20,30,40,50};

         foreach (var s in new List<int> {1,2,3,4,5 })
         {
            Console.WriteLine(foo.Where(id => id == s*10).First());  // <--- bei dem s meckert er
         }
      }
   }
}

Und bin wegen dem Closure verunsichert.
Mir meckert Resharper "Access to modified closure" an.
Ich habe nun einiges gelesen und bin mir nicht sicher, was ich davon halten soll.

Es liefert mir hier fünf mal 50 aus, so wie ich es naiver weise erwarten würde.
Verstehe ich das richtig, dass das Problem eigentlich nur dann auftreten würde, wenn ich die Delegaten oder Lamdas zwischenspeichern würde? (Geht das überhaupt mit lamdas)
Würd ich das: foo.Where(id => id == s*10).First()
zwischenspeichern, so hätte ich immer nur s = 5, korrekt?
Hätte ich eine lokale Variable eingeführt, die ich immer auf s lege, so würde dies wiederum gehen.
Verstehe ich das korrekt?

Wenn ja, warum meckert Resharper dann hier, der Kontext ist ja valide, wie ich meine

Danke für euer Feedback. Ich werde es mal so versuchen.

@JunkyXL: Ich habe leider nicht verstanden was du meinst.

Hallo,

ich refaktorisiere gerade ein wenig und habe nun eine .cs Datei die FormManager heißt, darin ist eine Klasse die FormManager heißt.

Nun habe ich eine Klasse, die ein Property des Typs FormManager braucht. Üblicherweise sind Properties ja groß geschrieben, was bei mir zu dem Ergebnis führt, dass ich folgendes habe:

 public FormManager FormManager { get; private set; }

Tja, Klasse und Instanz heißen hier gleich, was nicht geht. Aber ich finde den Klassennamen so eindeutig, dass die Instanz auch so heißen sollte, da ein public Property aber nun mal groß geschrieben wird, habe ich ein Problem.

Wie macht ihr so etwas? Ich will ungern die Instanz als "Forms" bezeichnen, weil ich gerade gemerkt habe, dass alleine das Wochenende dazwischen gereicht hat, um die Verbindung zwischen dem Namen und der Tatsache, dass es ein Manager ist, zu vergessen.
(Es war kein Alkohol im Spiel 😃 )

Wenn das Event im Handler selbst nicht ausgelöst werden kann, kann man das sicher so auch irgendwie lösen. Ich habe aber eine Situation wo eine Methode, die nichts mit dem Handling zu tun hat, Sachen macht, die auch nicht zum Aufruf des Handlings führen dürfen.
Wenn man das dann noch für verschiedene Handler hat, wirds kompliziert.

Ist aber eine interessante Idee und ich werde mal ein wenig drüber nachdenken, ob man das generischer lösen kann.

Edit: Das Problem bei mir ist, dass ein Handler für 40 Controls gleich ist. Sprich ich kann nicht ein Control übergeben (also kann ich schon, aber nützt mir nichts)

Ich müsste irgendwie die Handling Methode an Foo übergeben und es müsste so eine art on the fly Uberschreibung machen, so dass in dem Scope von Foo die Methode nichts macht.

Btw: Implicit hat es wirklich gebracht 😃

implicit könnte helfen! Danke 😃

Verhindern tut die Klasse die Ausführung des Events nicht wirklich, aber wenn ich so etwas habe:

protected void einEventHandler()
{
  // Code der wieder diesen Handler aufrufen würde
}

so ist ja eine Möglichkeit die Rekursion zu verhindern in dem man nen bool nimmt

protected void einEventHandler()
{
  if(eventEnabled)
  {
     eventEnabled = false;
     // Code der wieder diesen Handler aufrufen würde, was er aber nicht tut
     eventEnabled = true;
  }
}

Und weil man nun hier öfter immer irgendwo eventEnabled = false; Code; eventEnabled = true; schreiben müsste und man das eine oder andere vergessen könnte, habe ich Foo gebaut, um das eleganter zu Verpacken:

protected void einEventHandler()
{
  if(eventEnabled)
  {
     using(new Foo(eventEnabled))
     {
        // Code der wieder diesen Handler aufrufen würde, was er aber nicht tut
     }
  }
}

Da darf der bool nur kein bool, sondern ein Referenztyp sein

Was für den Background: Die Foo Klasse erbt von IDisposable und soll so etwas wie ein Event freien Scope bereitstellen.

In einem anderen Thread hab ich gefragt wie man verhindert, das Events gefeuert werden, wenn man bereits in dem Event ist und es nochmal auslöst.
Die Quintessenz war ein bool eventEnabled, den man beim Ausführen des Event-Codes auf false und nach dem Ausführen wieder auf true setzt.

Da ich aber keine Lust habe jedes mal die Flags zu setzen (und es mal vergessen werde 😃 ) und da man den Scope des Eventfreien raums nicht gut erkennt, habe ich den bool tatsächlich in einer Klasse Bool gekapselt.

Diese Klasse wird nun an die Foo Klasse gegeben, welche über using prima einen Scope aufmacht, im Ctor den Bool deaktiviert und im Dispose wieder aktiviert.

using (new EventGate(myBool))
{
  // hier kein Event feuer
}

Zu blöd das ich den Operator = nicht überladen kann, dann könnte der Bool wie ein bool benutzt werden. Aber man kann nicht alles haben.

(Wahrscheinlich gibt es eine bessere Methode und ich erzähl euch eh nichts neues, aber so werden wenigstens ein paar Bytes auf irgend einer Platte mal genutzt bevor sie vergammeln 😄 )

Direkt das Beispiel:

public class Foo
{ 
   protected ref bool f_;
   public Foo(ref bool f)
   {
      // wie speicher ich die referenz?
   }
   public ~Foo()
   {
      // benötige hier die referenz auf das Objekt
   }
}

Ich habe eine Klasse die eine Referenz auf einen Bool bekommt, nun muss ich aber diese Referenz aktiv über die Lebenszeit der Klasse irgendwie transportieren.
Gibt es einen Weg einen derartigen Typen abzulegen?

Ich will quasi eine externe Variable im Ctor bekommen und ändern und dies im Dtor ebenfalls tun.

Danke

Hallo,

ich generiere dynamisch ca. 40 Dropdowns die mit Werten gefüllt werden.
Auf jedem Dropdown liegt ein Event handler für SelectedValueChanged. Wenn ein Dropdown einen anderen Wert bekommt müssen eine reihe von anderen Dropdowns nachgezogen werden. Ich habe es mir einfach gemacht, in dem ich einfach alle Dropdowns auf einmal aktualisiere.

Mein Problem, wenn der Wert sich ändert, ein Event gefeuert wird, welcher dann ein anderes Event mit formtierten Daten aufruft und die Reaktion auf das Event weitere Änderungen an den Dropdowns stattfinden, so ist das eine Rekursion, aus der man nicht mehr raus kommt.

Gibt es da was C# spezifisches oder ein Pattern, wie man das händelt? Eine mögliche Lösung wäre es, dass das Event, was das folge Event aufruft, bei allen 40 Dropdowns die Events entfernt und dann wieder hinzufügt. Finde ich sehr umständlich.

Gerade beim schreiben fällt mir noch ein anderer Weg über eine Instanzvariable die entscheidet, ob das Event weitergereicht wird.
Quasi ein Event lock. Ist das die gangbare Lösung für so etwas? Oder gibt es da einen Weg, Aktualisierungen der Dropdowns auszuführen ohne Events zu triggern?

Früh am Morgen und schon verwirrt.

Hab einen simplen String

  {0, 0.0, 0.0, 0.0, 0.0, 0.1},

und Match "{(.*)},"

RegexLab schmeißt mir korrekt zwei Gruppen raus:

0: {0, 0.0, 0.0, 0.0, 0.0, 0.1},
1: 0, 0.0, 0.0, 0.0, 0.0, 0.1

Wenn ich aber folgenden Code in C# habe:

  
var r = new Regex("{(.*)}", RegexOptions.IgnoreCase);
Match m = r.Match("  {0, 0.0, 0.0, 0.0, 0.0, 0.1},");
var str0 = m.Groups[0];
var str1 = m.Groups[1];

So liefern mir beide str0 und str1 beides Mal "{0, 0.0, 0.0, 0.0, 0.0, 0.1}"
Also ich hätte erwartet, dass das Ergebnis exakt das von Regex-Lab wäre, vor allem weil ich in Group 0 den gesammten Match erwarte, mir fehlt aber das Komma.
Die zweite Gruppe ist dann sowieso komisch, weil die Klammern dabei sind.

Offensichtlich muss ich etwas übersehen.

Edit: Ähm, wenn ich den Sample code hier in eine neue C# Konsolenanwendung packe und ausführe, läuft der Code genauso, wie ich erwarten würde.
Wenn ich den gleichen Code in meiner Projektmappe ausführe, klappt es nicht.

Edit2: Gelöst, da ich var str0 gemacht habe, habe ich garnicht gemerkt, dass ich keinen String sondern eine Gruppe bekommen habe, die im Debugger ein {} um die Repräsentation legt.
Oh mann

Ich habe mir so eine Methode implementiert.

Vom Design her habe ich eine Collection von allen möglichen Objekten A, von denen einige vom Typ T und einige sind und andere von T erben. Wenn ich nun Überprüfen will, wie viele Oberklassen vom Typ T in dieser Collection sind, so komme ich da nicht drum rum.
Fürs reine Zählen ist so etwas auch recht ungünstig:

var count = collection.Count<T>() - collection.Count<T_A>() - collection.Count<T_B>() ... ;

Ich habe ein IEnumerable welches T und von T abgeleitete Klasse hat, wenn ich nun ein OfType<T> aufrufe, bekomme ich alle Ts und alle davon abgeleiteten.
Gibt es eine Möglichkeit OfType strikt zu machen und von T abgeleiteten Klassen nicht zu selektieren?

Jeden Tag was neues 😃

Wenn ich ein IOrderedEnumerable (Ergebnis eines LINQ Queries) von Elementen mit Typ T habe und die Referenz auf eines dieser Ts besitze, gibt es dann einen Weg, das Element vor diesem Typen T zu selektieren? Ich bräuchte ein LINQ Query, was theoretisch in der Lage ist ein Lookahead zu machen, so könnte ich ein Select Query bauen, was prüft ob das nächste Element das referenzierte ist.