[C#] shared objects/methods

[Hcore]

Hallo,

ich habe eine Klasse mit sehr vielen Methoden und vergleichsweise wenigen Feldern.

Deswegen möchte ich die ganzen Methoden als "static" anlegen, damit sie zur Laufzeit nur einmal existieren.

Nun bekomme ich aber Probleme, wenn einzelne Objekte meiner Klasse auf die Methoden zugreifen, v.a. da das auch parallel geschehen kann, d.h. das zwei verschieden Objekte gleichzeitig die selbe Methode benutzen wollen/müssen.

Was nicht passieren darf, ist das erst das eine Zugriff hat und dann das andere, also fallen so Konzepte wie Mutex und Semaphoren schon mal weg (glaub ich).

Was ich bräuchte, wäre eine Art "read only" Zugriff auf die Methoden.

Oder auch komplett andere Ideen.

bye,

Hcore

[mhaedicke]

ich habe eine Klasse mit sehr vielen Methoden und vergleichsweise wenigen Feldern.

Was meinst du mit Feldern?

Deswegen möchte ich die ganzen Methoden als "static" anlegen, damit sie zur Laufzeit nur einmal existieren.

Soweit, so gut.

Nun bekomme ich aber Probleme, wenn einzelne Objekte meiner Klasse auf die Methoden zugreifen, v.a. da das auch parallel geschehen kann, d.h. das zwei verschieden Objekte gleichzeitig die selbe Methode benutzen wollen/müssen.

Was nicht passieren darf, ist das erst das eine Zugriff hat und dann das andere, also fallen so Konzepte wie Mutex und Semaphoren schon mal weg (glaub ich).

Nö ...

Statische Methoden sind statisch. Sie können auch nicht auf nicht-statische Inhalte ihrer eigenen Klasse zugreifen.

Problematisch kann es werden, wenn diese Methoden auf statische Variablen zugreifen und ändern (wenn diese Variablen in derselben Klasse definiert sind). Grundsätzlich solltest du alle Parameter die du brauchst der statischen Methode übergeben. Die übergeben Parameter, soweit du sie ändern willst, sollten zu einem instaziierten Objekt gehören. Dann kann dir nix passieren.

Falls du nur und außschliesslich statische Methoden hast (z.B. Konsolenanwendung), musst du dich selbst darum kümmern, dass die Methoden sich nicht gegenseitig in die Quere kommen. Stichwort: Singleton

Was ich bräuchte, wäre eine Art "read only" Zugriff auf die Methoden.

Was meinst du mit readonly? Meinst du so eine Art Singleton-Verhalten?

Falls ich was falsch verstanden hab.. einfach nochma posten.

MfG

[Hcore]

Was meinst du mit Feldern?

Äh, sorry, ich hab tatsächlich mal den C# Namen verwendet.

Gemeint sind member Variablen bzw. allg. Attribute.

Grundsätzlich solltest du alle Parameter die du brauchst der statischen Methode übergeben. Die übergeben Parameter, soweit du sie ändern willst, sollten zu einem instaziierten Objekt gehören. Dann kann dir nix passieren.

Genau so hab ich es auch gemacht.

Die statischen Klassen Methoden haben alle ihre benötigten Parameter und zusätzlich den Parameter Instanz Objekt, damit sie wissen auf welcher Instanz sie gerade arbeiten.

Die Frage ist, ob das jetzt noch alles parallel funktioniert, wenn ich mehrere Instanzen haben und diese alle gleichzeitig die selbe Methode benutzen.

Was ich nicht möchte ist, dass die statischen Methoden zu einem Art Flaschenhals werden.

Pseudocode (!!):

class blubb

{ int a,b,c;

public static void worker(object instance)

{//do something}

}

main

{ blubb o1,o2 = new blubb();

thread1(blubb.worker(o1));

thread2(blubb.worker(o1));

thread3(blubb.worker(o2));

start threads;

}

[bigredeyes]

Das lock-Schlüsselwort kennzeichnet einen Anweisungsblock als wichtigen Abschnitt, indem die Sperre für gegenseitigen Ausschluss eines bestimmten Objekts ermittelt, eine Anweisung ausgeführt und die Sperre wieder aufgehoben wird. Die Anweisung hat das folgende Format:

lock(expression) statement_block

Hierbei ist:

expression

der Angabeort des Objekts, das gesperrt werden soll. expression muss einen Verweistyp darstellen.

In der Regel handelt es sich bei expression um einen von zwei Ausdrücken: "this", falls Sie eine Instanzenvariable schützen möchten, oder "typeof"(class), falls Sie eine "static"-Variable schützen möchten oder falls der kritische Abschnitt in einer statischen Methode der angegebenen Klasse auftritt.

statement_block

die Anweisungen des kritischen Abschnitts.

Hinweise

Mit lock wird sichergestellt, dass ein Thread nicht auf einen kritischen Abschnitt des Codes zugreift, während ein anderer Thread mit diesem Codeabschnitt befasst ist. Wenn ein anderer Thread versucht, auf gesperrten Code zuzugreifen, wartet er bis zur Freigabe des Objekts (Blockierung).

Unter 8.12 Die lock-Anweisung wird lock behandelt.

Beispiel 1

Im folgenden Beispiel wird eine einfache Verwendung von Threads in C# gezeigt:

// statements_lock.cs

using System;

using System.Threading;




class ThreadTest 

{

   public void runme() 

   {

      Console.WriteLine("runme called");

   }


   public static void Main() 

   {

      ThreadTest b = new ThreadTest();

      Thread t = new Thread(new ThreadStart(b.runme));

      t.Start();

   }

}

Ausgabe runme called Beispiel 2 Im folgenden Beispiel werden Threads und lock verwendet. Solange die lock-Anweisung vorhanden ist, stellt der Anweisungsblock einen kritischen Abschnitt dar und balance wird niemals negativ werden. // statements_lock2.cs

using System;

using System.Threading;


class Account 

{

   int balance;


   Random r = new Random();


   public Account(int initial) 

   {

      balance = initial;

   }


   int Withdraw(int amount) 

   {


      // This condition will never be true unless the lock statement

      // is commented out:

      if (balance < 0) 

      {

         throw new Exception("Negative Balance");

      }


      // Comment out the next line to see the effect of leaving out 

      // the lock keyword:

      lock (this)

      {

         if (balance >= amount) 

         {

            Console.WriteLine("Balance before Withdrawal :  " + balance);

            Console.WriteLine("Amount to Withdraw        : -" + amount); 

            balance = balance - amount;

            Console.WriteLine("Balance after Withdrawal  :  " + balance);

            return amount;

         }

         else 

         {

            return 0; // transaction rejected

         }

      }

   }


   public void DoTransactions() 

   {

      for (int i = 0; i < 100; i++) 

      {

         Withdraw(r.Next(1, 100));

      }

   }

}


class Test 

{

   public static void Main() 

   {

      Thread[] threads = new Thread[10];

      Account acc = new Account (1000);

      for (int i = 0; i < 10; i++) 

      {

         Thread t = new Thread(new ThreadStart(acc.DoTransactions));

         threads[i] = t;

      }

      for (int i = 0; i < 10; i++) 

      {

         threads[i].Start();

      }

   }

}

code stolen form ms-help

bigredeyes

[mhaedicke]

Da sich deine Frage offensichtlich auf Thread-Safety bezog hat bigredeyes wohl alles beantwortet, oder?

[Hcore]

Im Prinzip ja.

Also ist es jetzt so, dass meine einzelnen statischen Methoden alle "gleichzeitig" laufen können solange sie nicht schreibend auf Variablen zugreifen?

[mhaedicke]

Das wär jetzt wurscht.

[Hcore]

Hmm, doch nochmal konkreter werden.

Was ich nicht will, ist dieser lock Mechanismus, weil der ja verhindert, dass threads gleichzeitig auf bestimmten Bereichen laufen.

Solange ich keine kritische Bereiche in Methoden hab, wo also z.b. Attribute geschrieben werden, brauch ich diesen Mechanismus nicht. (wenn ich es richtig verstanden hab, bin heute etwas durcheinander) (es hat mich halt verwirrt, weil alle Beispiele zum Thema threading, die ich gefunden hab, immer nur nicht statischen Methoden verwenden)

[Bubble]

ich habe eine Klasse mit sehr vielen Methoden und vergleichsweise wenigen Feldern.

Deswegen möchte ich die ganzen Methoden als "static" anlegen, damit sie zur Laufzeit nur einmal existieren.

Die Methoden existieren nur 1x, egal wie viele Instanzen Du erzeugst. Beim Aufruf nicht statischer Methoden (=Instanz des Objektes vorhanden), wird lediglich unsichtbar ein Verweis auf die zu verwendende Instanz übergeben.