C# Anonyme Klassen

[captmcneil]

Hallo zusammen,

Ich komme aus der Java-Ecke, und bin schon längers am Suchen, ob es eine Möglichkeit gibt, in C#/VB.Net sowas wie anonyme Implementierungen vorzunehmen.

In diesem Zusammenhang lese ich oft etwas von delegates und Lambda-Expressions, allerdings weiß ich nicht, wie ich soetwas damit hinbekomme.

Ein Beispiel in Java:

Ich habe eine Liste mit Objekten, die ich sortieren möchte. Dafür benutze ich einen Comparator, den es ja genauso in .NET gibt.

Nutze ich den Comparator nur an dieser Stelle, wäre es etwas umständlich, eine Inner-Class zu deklarieren die das Interface implementiert. In Java geht das ganz schick mit anonymen Typen. Statt

private class MyComparator implements Comparator<MyClass> {
	
	public int compare(MyClass o1, MyClass o2) {
		return 0;
	}
	
}

....

Comparator theComparator = new MyComparator();
List<MyClass> theList = ...;
Collections.sort(theList, theComparator);

kann man einfach

List<MyClass> theList = ...;
Collections.sort(
	theList,
	new Comparator<MyClass>() {
		
		public int compare(MyClass o1, MyClass o2) {
			return 0; // implementierung hier
		}
		
	}
);

schreiben.

Das ganze ist natürlich nicht wirklich essenziell. Trotzdem: geht sowas in C#? Ein einfaches "Nein" würde mir schon sehr weiterhelfen, weil ich dann nicht weiter suchen muss.

 

[a1609s]

Wenn ich Dich richtig verstanden habe, dann suchst Du etwas, das sich in C# und VB.Net,
GENERIKA nennt.

Genauere Informationen über Generkia findest Du in der MSDN unter: Generika
bzw. hier für den: Generic-Namespace

Ich hoffe ich konnte Dir weiterhelfen
lg
A1609s

 

[captmcneil]

Nein, mit Generics hat das ganze gar nichts zu tun, außer dass ich hier zufällig einen verwendet habe.

 

[Darii]

In C# könntest du die Liste einfach über LINQ sortieren.

 

[Grantig]

Mit delegates liegst du schon ganz richtig.
Ich hab mal ein kleines Beispiel gebastelt:

        static void Main(string[] args)
        {
            List<MyClass> list = new List<MyClass>();

            list.Add(new MyClass(1));
            list.Add(new MyClass(123));
            list.Add(new MyClass(11));
            list.Add(new MyClass(333));

            Console.WriteLine("Before Sort:");
            foreach (MyClass cls in list)
            {
                Console.WriteLine(cls.Number.ToString());
            }


            list.Sort(delegate(MyClass obj1, MyClass obj2)
            {
                return obj1.Number - obj2.Number;
            });


            Console.WriteLine("\nAfter Sort:");
            foreach (MyClass cls in list)
            {
                Console.WriteLine(cls.Number.ToString());
            }

            Console.ReadKey();
        }

        class MyClass
        {
            public int Number
            {get;set;}

            public MyClass(int number)
            {
                this.Number = number;
            }            
        }

 

[captmcneil]

@Darii Es ging mir um syntaktische Möglichkeiten, Interfaces zu implementieren, aber nicht um dieses Interface speziell. Ich hätte genausogut ein anderes nehmen können. War das sooo missverständlich, dass mir hier sofort einer mit Generics und der andere mit Linq kommt?

@Grantig Hmm, für mich sieht das so aus, als ob das nur klappt, weil List.Sort eine Überladung für Delegates hat. Was ist, wenn ich ein eigenes Interface implementieren will, und nicht gerade IComparable? Delegate geht doch nur auf Funktionen, oder? Ich will ja ein Interface implementieren.

Java-Beispiel:

interface TestIF {
   void doCool();
   void doStuff();
}

...

void main(String[] args) {
  // hierum gehts: "new TestIF", und Interface implementieren -> geht in C# nicht?
  TestIF theTest = new TestIF() {
    public void doCool() {
      System.out.println("Hallo Welt");
    }
    public void doStuff() {
      // irgend ein Code
    }
  };
  theTest.doCool(); // "Hallo Welt"
}

Ich will also schon ein Objekt vom Typ TestIF haben am ende, nicht nur eine Funktionsreferenz.

Wie gesagt, ich glaube, dass das nicht geht, wäre nur cool, wenn mir das jemand bestätigen könnte.

 

[DerEineDa]

Gibt es leider nicht. Quelle unter anderem: http://en.wikipedia.org/wiki/Comparison_of_C_Sharp_and_Java

Sehr schade, ich benutze anonyme Klassen auch gerne in Java. Aber ok, das ist nicht immer schön, aber kurz

 

[Grantig]

@Grantig Hmm, für mich sieht das so aus, als ob das nur klappt, weil List.Sort eine Überladung für Delegates hat.

Jo, stimmt. Ich hab gedacht du brauchst ein Beispiel, wie man delegates verwendet, hab irgendwie dein Hauptproblem überlesen, sorry^^


Wie schon gesagt, anonyme Klassen gibt es in C# nicht.
Aber in den meisten Fällen, in denen man in Java anonyme Klassen benutzt, kann man in C# delegates benutzen. Das ist dann oft sogar kürzer.

Hier mal ein kleiner Vergleich, vllt interessiert dich das ja: klick

 

[captmcneil]

Okay, vielen Dank. Der Link ist in der Tat interessant.