Interfaces in DotNet ganz anders?

[Robert_G]

"Thread titel

Interfaces in DotNet ganz anders?

Zum Glück auch.

Zitat von Fingolfin:

1) Kann ich dem GC trauen?

Solange du nicht wie ein VB'ler wild drauf los erzeugst ist alles in Butter.

Zitat von Fingolfin:

2) PerformanceIch mache hauptsächlich Multimedia-Anwendungen mit einer gehörigen Menge beweglicher Grafik. Insofern kann es manchmal zu nicht unerheblichen Performance-Einbrüchen kommen, wenn die Bilddaten nicht definiert und regelmäßig freigegeben werden, sondern sich der GC irgendwann mal dazu bequemt, diese Objkte freizugeben.

Und du bist dir sicher, dass du da mit D32 besser dran warst? In Delphi32 gibt es einen messbaren Performance hit bei der Verwendung von Interfaces. Außerdem

Zitat von Fingolfin:

3) OO-Design
Wie ich schon vorher erwähnte, gibt es doch viele Momente in denen die Freigabe eines Objekts andere Objekte darüber benachrichtigt, damit diese irgendein Verhalten ausführen können.

Was hindert dich daran einen Event im Finalizer oder in der Dispose zu feuern?


Warum bin ich froh, dass Interfaces in .Net mit denen aus D32 nicht viel gemeinsam haben?
Hast du schonmal versucht die Klasse hinter einer Interfaceinstanz abzufragen?
Ich kenne nur dieses scheußliche Workaround.

Delphi-Quellcode:

type ISomeInterface = interface
   procedure Allright();
   procedure Hmmm();
   // scheußliches Workaround :[
   function  ComparableInstance() :TObject;
end;

type TSomeImplementingClass = class(TInterfacedObject,ISomeInterface)
   public
      procedure Allright();
      procedure Hmmm();
      function  ComparableInstance() :TObject;
end;

{ TSomeImplementingClass }
procedure TSomeImplementingClass.Allright();
begin
   Writeln('OK :thuimb:');
end;

procedure TSomeImplementingClass.Hmmm();
begin
   Writeln(':gruebel: Hmmm...');
end;

function TSomeImplementingClass.ComparableInstance(): TObject;
begin
   Result := Self;
end;

var
   NewInstance :ISomeInterface;
begin
   NewInstance := TSomeImplementingClass.Create();

   if NewInstance.ComparableInstance() is TSomeImplementingClass then
      NewInstance.Allright()
   else
      NewInstance.Hmmm();

   Sleep(3000);
end.

Da du in .Net die Referenzzählung nicht mehr selbst machen muss, sieht es auch gleich viel "aufgeräumter" aus.

Code:

   public interface ISomeInterface
   {
      void Allright();
      void Hmmm();
   }

   public class SomeImplementingClass : ISomeInterface
   {
      public void Allright()
      {
         Console.WriteLine("OK :thuimb:");
      }

      public void Hmmm()
      {
         Console.WriteLine(":gruebel: Hmmm...");
      }
   }

   internal class Program
   {
      private static void Main(string[] args)
      {
         ISomeInterface NewInstance = new SomeImplementingClass();

         if (NewInstance is SomeImplementingClass)
            NewInstance.Allright();
         else
            NewInstance.Hmmm();

         Thread.Sleep(3000);
      }
   }
}

Du kannst wie gehabt den is-OIperator benutzen. (verhält sich schließlich wie eine Objektreferenz )

Edits: Schlechtschreibung...