• Du befindest Dich hier:
• Community
• »
• Mitglieder
• »
• MarsStein
• »
• Beiträge von MarsStein

t = new Test(); // <-- Was passiert hier?

Wenn Du t zuerst auf null stellst, passiert genau dasselbe, durch die Zuweisung von null wird das Objekt auch nicht zerstört.
Aber da wir hier mit "Managed Code" zu tun haben, macht das auch garnix. Wenn das Objekt nirgendwo mehr referenziert ist, räumt es irgendwann die Garbage-Collection weg.
Wenn Du das Objekt selbst explizit zerstören willst, solltest Du Dir mal das IDisposable-Interface ansehen.

Ich bin mir nicht sicher, aber bielleicht wird der DataGridView nach der Zuweisung des neuen DataSet einfach nicht neu gezeichnet. Dann könnte ein dgv.Invalidate() helfen.

Das ist immer dann so, wenn Du eine Variable nicht zusammen mit der Deklaration initialisieren kannst. Wenn Du also im gleichen Aufruf deklarierst und zuweist, geht das auch bei Arrays:

int[] test = new int[]{1,2,3,4};

Sowas geht. Dazu muss auf dem Server, auf dem der IIS läuft, der RemoteDebugger installiert werden und laufen, ist mit auf der VS2005 CD. Dann kannst Du über das Debug-Menü von Deinem PC aus Dich auf den Server verbinden. Mehr dazu unter "RemoteDebugger" im Google.

Oder direkt hier:
http://msdn.microsoft.com/netframework/programming/64bit/remotedebugging/

Hier nochmal Dein Code mit dem Konstruktor, bei mir läßt sich das so übersetzen und läuft auch!!

using System;
using System.Diagnostics;

//Klasse zum Ausgeben des Menüs
class ProgrammeMenue {

   string[,] Applikationen = new string[3,2];
   public ProgrammeMenue(){
    Applikationen[0,0] = "Editor";
    Applikationen[0,1] = "notepad.exe"; 
   }

  private int LetzteAuswahl = 0;
  
  public void Ausgeben()
  {
    Console.WriteLine("---------------------------------------------------------------------------");
    Console.WriteLine("Hallo Welt - Ein Menueprogramm fuer Systemapplikationen *lol*");
    Console.WriteLine("---------------------------------------------------------------------------\n");
    Console.WriteLine("Um eine Systemprogramm zu starten, geben Sie die entsprechende Zahl ein.\n");
    
    Console.WriteLine("<1> Explorer");
    Console.WriteLine("<2> Editor");
    Console.WriteLine("<3> Registrierungseditor");

    Console.Write("\n");

    Console.WriteLine("<0> Beenden");
    
    Console.Write("\n");
  }
  
  public void Eingeben()
  {
    Console.Write("--> Ihre Eingabe: ");
    string Eingabe = Console.ReadLine();
  }
  
  public void Auswaehlen(int AuswahlNr)
  {
    if (AuswahlNr == 0)
    {
      LetzteAuswahl = 0;
    } else {
    
    } 
  }
  
  public int GetLetzteAuswahl()
  {
    return LetzteAuswahl;
  }

    // Process.Start("regedit.exe");
}


public class Test01
{
  public static void Main()
  {
    // Hauptmenü deklarieren als Instanz der Klasse "Menue"
    ProgrammeMenue Hauptmenue = new ProgrammeMenue();
    // 
    bool Hauptmenue_schliessen = false;

    while (!Hauptmenue_schliessen) {
      Hauptmenue.Ausgeben();
      Hauptmenue.Eingeben();
      if (Hauptmenue.GetLetzteAuswahl() == 0)
      {
        Hauptmenue_schliessen = true;
      }
    }

  }
}

Versuch mal einen Konstruktor für Deine Hauptmenüklasse zu schreiben und das Array erst dort mit Werten zu initialisieren.

class Hauptmenue
{
  private string[,] Applikationen = new string[3,2];

  Hauptmenue(){
    Applikationen[0,0] = "Editor";
    Applikationen[0,1] = "notepad.exe";  
  }
/* usw. */
}

lock(var){...} ist eine Blockanweisung, wenn die geschweifte Klammer geschlossen wird, ist die Variable wieder frei. Ein "unlock" gibts meines Wissens nicht.

Ich würde das so machen:
Das Interface IRotatableAds

public AdType Type
{
  get;
}

void BuildNewAd(RotateAds myControl);

public static List<IRotatableAds> adsList;

foreach(IRotatableAds ads in adsList)
{
  if(ads.Type == adType)
  {
    ads.BuildNewAd(this)
  }
}

In der Global.asax kannst du einen Handler für das Ereignis HttpApplication.PostRequestHandlerExecute schreiben. Google hierzu mal nach "global.asax" und "PostRequestHandlerExecute". Da müsstest du dann irgendwie auf die gerenderte Page zugreifen können - notfalls über den Response-Stream.

Wenn das alles auf einem IIS läuft, kannst du so vorgehen, wie ich oben gepostet habe. Der asp.net-Prozess stellt dem Webservice die Appliation-Collection zur Verfügung. So eine Collection gibts einmal für jeden Webservice im IIS. Da der asp-Prozess weiterlebt und nicht beendet wird ausser wenn Du den IIS beendest, ist diese Collection dann quasi für alle Threads statisch.

Andersrum gesagt: Es werden zwar 2 Instanzen des Webservice erdtellt, diese laufen aber im selben Prozesss. Dies ist der ASP-Prozess (aspwp.exe), der weiterlebt un damit Applikationsdaten für den gesamten Webservice halten kann.

Wenns mehrere Server gibt, kann man einen zentralen Webservice zur Verfügung stellen, der nichts anderes als mein Beispiel von oben tut und dann "selector" per WebMethod zurückgibt. An den können sich dann die verteilten Server wenden

Wie meinst Du das mit der neuen Instanz?
Wenn es sich um einen ASP.NET Webservice handelt, laufen die alle unter dem aspnet-workerprozess, und der wird nicht beendet. Dann reicht dir ein statischer Member in deiner Webservice-Klasse oder ein Eintrag in der Application[]-Collection. Im Konstruktor kannst Du dann diesen dann durch lock() threadsafe für weitere Auswertungen puffern.

class MyWebService: System.Web.Services.WebService
{
  int selector = 0;
  MyWebService()
  {
     if(Application["Selector"]==null)
     {
        Application["Selector"] = selector;
     }
     else
     {
        lock(Application["Selector"])
        {
          selector = (int)Application["Selector"];
          selector  ++;
          Application["Selector"] = selector;
        }
     }
  }
  /*
  WebMethods
  */
}