Wo startest du den Befehl denn. Er muss am Client abgesetzt werden.

Wobei du beim Compact Framework auf .NET 2.0 Webservices beschränkt bist (aspx). Obwohl ja das 3.5 Framework auch andere Bindings unterstützt (wsHttpBinding) wirst du aus dem 3.5 CompactFramework nicht darauf zugreifen können.

Nun wede ich im deklarativen teil immer ne DB Verbindung herstellen müssen. Es gibt sicher eine Möglichkeit, damit ich nicht immer den gesamten Code schreiben muss um eine verbindung herzustellen (auslagern des "connection"-codes)

Zentral speichern tust du lediglich den ConnectionString, z.B. in der web.config Datei. Sobald du eine Anfrage an den DB Server absetzen willst, erstellst du eine neue Connection, die du anschliessend wieder schliesst. Eine geshared Connection zu verwendung (z.B. irgendwo statisch abzulegen) kommt einem Kopfschuss gleich, gerade bei Webanwendungen die dafür ausgelegt sind, mehrere Benutzer gleichzeitig zu servieren (siehe hier) (Ich bin also schon gerichtet). Das Öffnen (Erstellen) einer neuen Connection und wieder Schliessen geht dank dem ConnectionPooling resourceschonend über die Bühne.

Hast du den Befehl denn schon ausprobiert.

Die Grouppolicies werden nunmal, je nach Wichtigkeit, entweder direkt oder eben nur zeitverzögert übernommen. Dirket übernommen werden z.B. Passwortänderung oder Accountsperrungen, verzägert eben die Gruppenzugehörigkeiten. Mit dem Befehl kannst du das aber manuell übernehmen.

Arbeitest du in einer Domain?

Über die Commandline kannst du das so machen:

gpupdate /force

Ich möchte alle Projekte für einen User XY haben, wo er 1. im Team ist oder Projektleiter ist. Jedoch sollen nur die Projekte ausgegeben werden, in denen Aufgaben sind, in denen der Benutzer im Team oder Leiter ist.

Was möhtest du denn nun? Eine List der Projekte oder eine Liste der Aufgaben.

ad 1: Kommt darauf an. Ich gebe bei Methoden, die ein einzelnes Objekt zurückgeben, null zurück, bei Methoden, die eine Liste zurückgeben, eine leere Liste. Sinn

Genauso handhab ich das auch. Eine leere Liste hat ja primär erstnmal nur eine Containerfunktion, und beherbergt andere Objekte. Wenn keine anderen da sind, ist sie leer. Aber ein foreach läuft prim darüber, auch wenn nichts weiter passiert.
Bei normalen Objekten geb ich aber null zurück, wenn es keinen Sinn macht, überhaupt etwas zurückzugeben. Wenn nicht alle Bedingungen erfüllt sind, warum also ein leeres Objekt zurückgeben: Denn auch ein leeres Objekt beinhalte Informationen, und es könnten Methoden aufgerufen werden, die gar nicht sinnvoll sind oder gar zu Fehlern führen. Dann lieber null zurückgeben, und wissen, dass die Klasse halt nicht instanziert wurde.

wegen der schon genannten unbemerkten Bitkipper

(So ein Bitkipper passiert öfters als man denkt (bitte ein Bit) 8)){gray}

Wozu, wenn ich fragen darf?

Ich finde ebenfalls Windowsbotschaften recht praktisch für solche Dinge. Denn du bist auf jeden Fall sicher dass die Message ankommt. Darauf reagieren kannst du per Event. WM_COPYDATA ist das Stichwort das dir bei der Suche helfen wird.

Primär DataSet und DataAdapter. Liegt aber auch daran dass ich primär noch in .NET 2.0 unterwegs bin, und ich somit auch noch keine grosse Einarbeitung in LINQ of EF brauchte. Ändert sich aber vielleicht mal.

Das mit der Sprachkompatibilität ist eh ein Problem. Während c# zwischen myVar und MyVar unterscheidet, tut dies VB.NET z.B. nicht. Es ist aber Konvention, Felder oftmals klein und die entsprechenen Eingenschaften dazu Gross zu schreiben. Bindet VB.NET eine solche DLL ein, kann es zu Problemen kommen, zumindest dann wenn das Feld nicht als Private sondern als Piblic deklariert wurde. Soll man zwar nicht machen, ist klar, aber es würde unverweigerlich zu Problemen führen und die Klasse in der DLL könnte von einem VB:NET Projekt nicht referenziert werden.

Wenn dein Arbeitgeber von dir verlangt, eine Software zu schreiben, dann haften die nach aussen hin dafür. Solange du gewissenhaft deine Software testest, und nicht fahrlässig handelst, brauchst du so schnell keine Klage zu befürchten, und schonmal gar nicht als Praktikant.

mag ja alles sein, aber ich gehe davon aus, das die funktionen korrekt arbeiten, oder?

Die Funktionen arbeiten beide korrekt. Du musst halt nur wissen, in welcher Masseinheit die Argumente in sin und cos in der jeweiligen Sprache interpretiert werden. LaTino's hat's ja schon angedeutet, ich frag nochmal nach: Begriffe, wie Bogenmaß und Radient sind dir schon ein Begriff?

Ansonsten könnte man auch installutil.exe verwenden (
> )

Wozu natürlich auch das .NET Framework installiert sein muss.

Nur so als Bemerkung an Rande: falls es sich bei deiner connection um eine Datenbank Connection handelt, dann solltest du tunlichst vermeiden eine einzige Connection in deiner Anwendung zu sharen.

Bei CodeProject hab ich folgenden SelfInstaller Code gefunden. d.h. wenn du in dein Projekt selbst eine Installer Klasse hast (also aus System.Configuration.Install.Installer ableitest), dann wird dieser Code ausgeführt.

Könnte ja eventuell hilfreich sein bei deinem Vorhaben. Die Installer Klasse kannst du für alles Mögliche nutzen wie EventSources anlegen, Files kopieren usw.

using System.Reflection;
using System.Configuration.Install;

[csharp]    public static class SelfInstaller
    {
        private static readonly string _exePath =
            Assembly.GetExecutingAssembly().Location;
        public static bool InstallMe()
        {
            try
            {
                ManagedInstallerClass.InstallHelper(
                    new string[] { _exePath });
            }
            catch
            {
                return false;
            }
            return true;
        }

        public static bool UninstallMe()
        {
            try
            {
                ManagedInstallerClass.InstallHelper(
                    new string[] { "/u", _exePath });
            }
            catch
            {
                return false;
            }
            return true;
        }
    }

Du könntest einen Job im SQL Server definieren, der periodisch automatisch ausgeführt wird. Dieser Job würde dann einfach alte Datensätze in die 2. DB kopieren, und anschliessend die Originaldatensätze löschen.

Befindet sich die andere Datenbank auf einem anderen Serversystem (z.B. Oracle), kannst du mittels Linked Server problemlos direkt aus der MSSQL DB auf die Oracle DB zugreifen.

EDIT: Shit.. Khalid war schneller 👍

Es gibt auch noch .NET Trigger seit SQL2005. Damit kannst du fast alles machen, das in normalem .NET auch geht.

Ich sage das deshalb, weil du eigentlich NUR so sicherstellen kannst, dass auch was passiert, wenn ein Record änderte / hinzukommt / gelöscht wird. Läuft dein Dienst aus irgendeinem Grund mal nicht, sq kriegst du änderungen gar nicht erst mit. Solche Sachen gehören imho direkt in die DB, und nicht in einen getrennten Prozess.

Dann war ich ja gar nicht so falsch mit meiner Vermutung 🙂

Ich schwör dir, solch ein Fehler passiert mir nicht nochmal. 8) Ich schiebs mal (mit ganz ruhigem Gewissen) auf meine Einführungsphase in .NET. Ich wusst es damals einfach nicht besser. :evil:

Ich versuche mich gerade an einer Anwendung, die über SqlDependeny eine Datenbank überwacht und bei Änderungen die Daten in eine andere Datenbank schreibt.

Wären solche Aktionen nicht sinnvoller in einem Trigger aufgehoben?

Ok, ich habe DEN Fehler beseitigt. Das erste Laden dauert zwar noch immer, und auch bleibt das Problem, dass nach einer gewissen Inaktivität am server wieder ein Laden lange dauert, aber zumindest funktioniert nun bei mir die Methode mit dem Windowsdienst der periodisch sich einfach eine Seite des Webs runterlädt. Somit ist sichergestellt, dass der Garbage Collector (oder IIS) den Cache wieder räumt.

Es klappt jetzt also.

Zu meinem RIESEN, HAUT AUF MICH DRAUF Fehler im Serverprozess: an einer Stelle wurde eine über, böse statische SqlConnection genommen, die andauernd offen war. Dass das zu Problemen führt im Multiuserbetrieb muss ich nicht erwähnen. Wie auch immer es zu diesem Disaster kam, keine Ahnung. Muss noch aus Code aus meinen Gehversuchen aus Anfangszeiten stammen...

Damit sind auf einmal auch die automatischen Restarts vom IIS verschwunden.

Ich glaub, ich muss einen ausgeben. 8)

WindowsForms DLLs solltest du wenn möglich nicht referenzieren.
...
Interessant wäre, welche Referenzen deine referenzierten DLLs aufweisen.

Hmm, kann das wirklich der Grund sein? Ich nutze ja nichts aus den Gui Klassen, sie sind halt nur in einigen Libs enthalten. Aber ich werds mal austesten, wird aber nicht so einfach werden, da relativ viel damit zusammenhängt, und ich so die ganzen DLLs aufsplitten muss. Wär aber wohl eh von Vorteil.

Mir ist eben folgendes im IIS Log aufgefallen:

2009-03-25 10:43:20 10.16.103.30 GET /public/Default.aspx - 80 - 10.16.103.30 - 200 0 0
2009-03-25 10:43:20 10.16.103.30 GET /public/FallPatient.aspx - 80 - 10.16.103.30 - 200 0 0
2009-03-25 10:43:20 10.16.103.30 GET /public/Agression.aspx - 80 - 10.16.103.30 - 200 0 0
2009-03-25 10:43:20 10.16.103.30 GET /public/GeneralIncident.aspx - 80 - 10.16.103.30 - 200 0 0
#Software: Microsoft Internet Information Services 6.0
#Version: 1.0
#Date: 2009-03-25 11:00:40
#Fields: date time s-ip cs-method cs-uri-stem cs-uri-query s-port cs-username c-ip cs(User-Agent) sc-status sc-substatus sc-win32-status 
2009-03-25 11:00:40 10.16.103.30 GET /Default.aspx - 80 - 10.16.98.36 Mozilla/4.0+(compatible;+MSIE+7.0;+Windows+NT+5.1;+HSL+GPO;+HSL+GPO+less;+.NET+CLR+1.1.4322;+.NET+CLR+2.0.50727;+.NET+CLR+3.0.04506.30;+InfoPath.2;+.NET+CLR+3.0.04506.648;+.NET+CLR+3.5.21022;+.NET+CLR+3.0.4506.2152;+.NET+CLR+3.5.30729;+HSL+GPO;+HSL+GPO+less;+HSL+GPO;+HSL+GPO+less) 302 0 0
2009-03-25 11:00:40 10.16.103.30 GET /public/Default.aspx - 80 - 10.16.98.36 Mozilla/4.0+(compatible;+MSIE+7.0;+Windows+NT+5.1;+HSL+GPO;+HSL+GPO+less;+.NET+CLR+1.1.4322;+.NET+CLR+2.0.50727;+.NET+CLR+3.0.04506.30;+InfoPath.2;+.NET+CLR+3.0.04506.648;+.NET+CLR+3.5.21022;+.NET+CLR+3.0.4506.2152;+.NET+CLR+3.5.30729;+HSL+GPO;+HSL+GPO+less;+HSL+GPO;+HSL+GPO+less) 200 0 0
2009-03-25 11:00:40 10.16.103.30 GET /defaultStyle.css - 80 - 10.16.98.36 Mozilla/4.0+(compatible;+MSIE+7.0;+Windows+NT+5.1;+HSL+GPO;+HSL+GPO+less;+.NET+CLR+1.1.4322;+.NET+CLR+2.0.50727;+.NET+CLR+3.0.04506.30;+InfoPath.2;+.NET+CLR+3.0.04506.648;+.NET+CLR+3.5.21022;+.NET+CLR+3.0.4506.2152;+.NET+CLR+3.5.30729;+HSL+GPO;+HSL+GPO+less;+HSL+GPO;+HSL+GPO+less) 304 0 0

Der IIS scheint wohl aus irgendeinem Grund neu gestartet zu haben, warum auch immer, weil Fehlermeldungen gibts nirgends.

Ich bleib mal dran, gerade was das Referenzieren der DLL's angeht.

Hallo Peter,

wenn, dann tendierte ich auch eher zum eigenständigen Windowsdienst.

Einen Grund, dass die Anwendung zusammenbricht, sehe ich nicht. Ich gehe wirklich davon aus, dass es an den zisch DLLs liegt, die ich mit als Referenz verlinkt habe. Zum Test habe ich mir mal eine wirklich simple ASPX Seite gebastelt. Diese startet recht flott, auch beim ersten Start. Aber sobald ich die Bibliotheken verlinken, auch ohne sie zu nutzen, dauert der Aufruf ewig. Die Bibliotheken sind nur eine Sammlung von Funktionen, die ich normalerweise immer wieder brauch. Darunter sind auch WinForms UserControls z.B., aber ich nutze die natürlich nicht in der ASP.NET Anwendung. Könnte es wirklich daran liegen, glaub ich nicht. Die Anwendung läuft ja problemlos, halt nur ab und zu langsam. Fehlermeldung in irgendwelchen Logfiles hab ich bislang keine gehabt. Und der Server selbst langweilt sich eigentlich: ist irgendeine Quadcore Kiste im Rack mit Win2003 und 4GB RAM. Viel läuft auf der Kiste nicht, und der RAM Bedarf bleibt +/- konstant.

Anderer Server, sprich meine eigene Entwicklerkiste mit XP, ändert nix am Verhalten.

Also ich habe nun einiges getestet, allerdings führt nichts so richtig zum Erfolg:*Im ApplicationPool des IIS habe ich die "timeout" und "recycle worker processes" hochgeschraubt. Das ändert nichst am Verhalten. *Mein gut gemeinter Hack über die global.asax File (siehe Code unten) brachte auch nichts *Ein Windows Service, der mir alle 2 Minuten die Seiten aufruft ebenfalls nix.

Das Verhalten ist und bleibt untragbar. Ein erster Aufruf der Seiten dauert eine gefühlte Ewigkeit, danach läufts ganz flüssig. Wird am Webserver jedoch für eine gewisse Zeit nichts aufgerufen, greift wohl der Garbage Collector, und ein nächster Aufruf dauert wieder ewig.

Gerade letzter Versuch sollte doch vielversprechend sein. Ich rufe per Code alle 2 Minuten sämtlich aspx Seiten der Web auf. Diese Aufrufe erscheinen auch alle sauber im Log vom IIS. Und trotzdem habe ich nun wiederholt das Verhalten, dass ein manueller Aufruf über den IE wiederrum ewig dauern kann.

Ich bin echt am Verzwweifeln. Im Netz findet man auch nur so gut gemeinte Ratschläge, wie die 3 Punkte von mir oben. Bringt alles nix. Und davon mal abgesehen, selbst wenn das regelmässige Aufrufen funktionieren würde, kann das doch kein normales Verhalten sein. Ich muss meinen Wagen ja auch nicht jeden Tag mindestens einmal starten, weil er sonst nach 3 Tagen Pause nur schwer anspringt.

[edit]Ups, Code der global.asax vergessen[/edit]

    public System.Timers.Timer aTimer;
    private HSL.GCC.IConfiguration myConfig = IMA.Lib.Singleton.Instance.MyConfig;

    private string urlIma;
    private lu.csl.services.IMW imw;
         
    
    void Application_Start(object sender, EventArgs e) 
    {
        urlIma = "http://bubu";
        aTimer = new System.Timers.Timer();
        aTimer.Interval = 120000;
        aTimer.Elapsed += aTimerElapsed;
        aTimer.Start();
    }
    
        
    void Application_End(object sender, EventArgs e) 
    {
        //  Code that runs on application shutdown
    }

    protected void aTimerElapsed(object sender, EventArgs e)
    {
        // Call sample webservice method
        imw.Init();
        
        //URLs der Websites die am Leben erhalten werden soll:
        PerformLoad(urlIma);
        PerformLoad(urlIma + "/public/Default.aspx");
        PerformLoad(urlIma + "/public/FallPatient.aspx");
        PerformLoad(urlIma + "/public/Agression.aspx");
        PerformLoad(urlIma + "/public/GeneralIncident.aspx");
    }

    private void PerformLoad(string URL)
    {
        System.Net.WebRequest request = System.Net.WebRequest.Create(URL);
        System.Net.WebResponse response = null;
        response = request.GetResponse();
        System.IO.Stream responseStream = response.GetResponseStream();
        System.IO.StreamReader reader = new System.IO.StreamReader(responseStream);

        Application["LastResponse"] = reader.ReadToEnd();
    }

Aufruf dann so:

  
(Liste[0].CustomerObject as TCustomerExt).ExtString  
  

Verrennst du dich da nicht? Wenn du mehrere Ableitunge hast, läufst du schnell in unübersichtliche if-Bedingungen rein, also so
was:

if (Lists[0].CustomerObject  is TCustomerExt)
    return (Liste[0].CustomerObject as TCustomerExt).ExtString;
else if (Lists[0].CustomerObject  is TCustomerEx2t)
    return (Liste[0].CustomerObject as TCustomerExt2).ExtString2;
...

Vielleicht ist das Adapter-Pattern was für dich (siehe hier oder hier.

Am einfachsten gehts mit der BackgroundWorker Klasse.

Aber deine Denks- bzw. ausdrucksweise ist falsch. Es ist nicht Aufgabe des Threads, deine Progressbar zu aktualisieren, sondern es ist höchstens Aufgabe des Threads ein Event auszulösen, das die Gui abbonniert und dann selbständig daraufhin die Progressbar aktualisiert.

Am Precompilieren liegts nicht, weil meine Seite precompiliert sind.

Ich versuche aber gerade ein Hack in der global.asax aus. Wenn damit funktioniert, werd ich dazu Näheres hier schreiben.

Es ist ja schon ein älterer Thread, aber ich möchte den nochmal aufgreifen.

Ich habe genau dasselbe Problem. Mein erster Aufruf einer Seite dauert ebenfalls bis zu einer Minute, danach läufts ganz ordentlich. Ich weiss nicht, was ich dagegen unternehmen kann. ok, ich verweise auf etliche DLL's in der Anwendung, aber die sind auch notwendig. Es ist jedoch inakzeptabel, dass ich eine Minute auf eine Einstiegsseite warten muss, nur weil ich vielleicht auf einie DLL's verweise.

Das Tracing hat bei mir auch nichts an Kenntnis gebracht. Was bleibt mir noch übrig, und den Start zu beschleunigen.

Für mich macht es keinen Sinn, dass ich einer Funktion oder Methode NULL übergeben kann, wenn ein Objekt erwartet wird.

Alles in .NET sind Objekte, und eine Instanz einer Klasse kann nun mal auch den Werte null haben, d.h. das Objekt ist nicht instanziert. Also sehe ich keine Problem darin, einer Funktion die ein Objekt Parameter erwartet, dass dort eben ein "leeres" Objekt übergeben wird. Wenn das in der Funktion selbst nicht erlaubt sein soll, dann kannst du doch dort auf ein Leichtes auf null prüfen und gegebenfalls eine NullReferenceException mit einer genauen Fehlerbeschreibung schmeissen.

Was soll eine Methode mit NULL machen wenn ein Objekt erwartet wird? Das musst Du mir mal erklären.

Lässt du Null nicht zu, schränkt das das oben erwähnte Scenario nur unnötig ein. Persönlich nutze ich z.B. sehr oft überladene und parametrisierte Konstruktoren für Klassen, um die Instanzierung von aussen zu erleichtern. Oftmals wird aber einfach nur ein Parameter weggelassen, da vielleicht nicht bekannt. Lösen kann ich das dann ganz bequem so:

public Logging(MyHost host)
{
    this.host = host;
    if (host != null)
        Console.WriteLine("No host provided");
    else
        Console.WriteLine(string.Format("Logging for host {0}", host.Name);
}

und dazu z.B. einen parameterlosen Konstruktor:

public Logging() : this(null) { } 

d.h. ich habe meine ganze Funktionalität in einer Methode untergebracht. Wenn ich kein null zulassen dürfte, müsste ich neuen Code in meinen parameterlosen Konstruktor eingeben.

Wie gesagt, das Nicht-Zulassen von null schränkt nur ein, und bringt meines Erachtens keinerlei Vorteile, da zu jeder Zeit eine Prüfung auf null durchzogen werden kann, und entsrpechend darauf reagiert werden kann. Es widerspricht auch in keinster Weise dem OO Ansatz, da nun mal alle Objekte den Wert null haben dürfen.

string mail = Environment.UserName + "firmenname.de"  

Environment.UserName gibt dir zwar den Login aus. Die EMail Adresse im AD muss aber nicht zwingend so definiert sein.

Aber wenn man den Login erstmal hat, kann man sich ohne Probleme den ganzen Record aus dem AD holen

ActiveDirectoryInfo instanzieren und die Find-Methode aufrufen. Als Parameter entweder ein gültiges Login oder die Guid eines Users eingeben. Zurückgegeben wird so Einiges und halt eben auch die EMail adresse

Bei SafariBooksOnline gibts Probekapitel, allerdings nur auf englisch. Suche dort mal nach "Head First Design Patterns".

Das Buch kann ich auch wirklich nur empfehlen.

Und da du man einfach gesprochen die Plugins sowieso immer in die Basisklasse castest, wird auch immer "dein" Load aufgerufen und nicht das mit new deklarierte.
Ein Benutzer kann seine Methode ruhig mit new "überschreiben", aber das bringt ihm rein gar nichts, da die "von außen" nie aufgerufen werden wird (aus o.g. Gründen).

Ach Mensch, ja genau. Du hast natürlich Recht. Ich arbeite sowieso wie du geschrieben hast mit der Basisklasse.

Danke. Irgendwie hatte ich mich da wohl verlaufen.

Du meinst (wie im Titel) "überschreiben", oder? ¨
Ja, natürlich. Hab mich nur verschrieben. Der Unterschied zwischen überschreiben und überladen ist mir natürlich bekannt.

Das mit dem new ist mir auch bekannt, und das will ich ja genau vermeiden. Ich habe eine Load() Methode in meiner Basisklasse, und die soll auch IMMER so ausgeführt werden, d.h. der Erbklasse darf die Load() nicht neu mittels new definieren.

Ich suche eigentlich sowas wie eine Sealed Class, aber halt nur für eine Methode. Eine Methode kann ich zwar als override sealed void Load() definieren, das verhindert aber nur, das in der Erbklasse Load überschrieben wird, nicht aber dass die Methode mittels new Load() einfach neu definiert wird.

Ich hätt da gern mal ein Problem.

Ich entwickle gerade an einem Pluginsystem. Die Erweiterungen müssen einem gewissen Schema entsprechen. Dafür habe ich mir eine Plugin Basisklasse erstellt, die auch schon gewisse Pflichtmethoden mit sich bringt. Ich verzichte bewusst auf ein Interface, da das Pluginsystem für unser internes Entwicklerteam gedacht ist. Soll eine neue Erweiterung erstellt werden, so wird von meiner Basisklasse geerbt, die Erweiterungen implementiert (im Grunde eine einzige Methode überschrieben), und diese DLL wird dann ins Plugin Verzeichnis kopiert, wo sie dann dynamisch von Programm geladen wird.

Warum kein Interface: weil die Basisklasse gewisse Lookups und Checks durchführen muss, und validiert, ob es sich um ein komplette gültiges Plugin handelt. Daher die Basisklasse, die die öffentlich Methode Load() enthält, die einige Dinge aus Datenbanken lädt. Diese Methode ist so elementar wichtig für die Funktionalität, und ich möchte daher sicherstellen, dass sie auf keinen Fall überladen wird in der abgeleiteten Klasse mittels new Load().

Wie kann ich das berwerkstellen. Oder gibt es eventuell ein Pattern, das ich nutzen könnte, damit meine Load() Methode unberührt bleibt, aber dennoch in der speziellen Pluginklasse verfügbar ist?

Ich hab den Thread jetzt nicht bis ins letzte Detail gelesen, aber imho fehlt dir sicherlich eine CardGame Klasse. Die Klasse hätte sicherlich solch nützlich Methoden wie

Player player = game.AddPlayer();
player.Name = "Bubu";

usw.

Das game-Objekte hält somit die Spieler in sich geborgen.
Dem game-Objekt würde ich, nachdem die Spieler definiert sind, auch die Spielmethoden verpassen, d.h. Methode wie ShuffleCards(), DistributeCards() wären meiner Meinung nach auch recht gut darin aufgehoben.

Ich nutze aus Gewohnheit immer gern englische Bezeichnungen für meine Klassen und Objekte

(

Liegt wohl an meinen beiden 6 und 8 jährigen Mädels, mit denen ich vielleicht zuviel pauke 😁 Die wissen noch nicht was ein Verb und Substantiv ist.

Hast natürlich recht 👍

Das mit den geschwieften Klammern seh ich ja noch ein. Dazu gehören ja auch Koneventionen zur Namensnennung von Klassen und Methoden (Dingwörter und Tuwörter). Aber die konsequente Bennnung von string oder String find ich, ehrlich gesagt, persönlich schon etwas zu perfektionistisch. Oder anders ausgedrückt: ich denke nicht, dass irgendjemand einen Code nur dadurch schlechter lesen kann, nur weil nicht durchgängig string oder String genutzt wurde.

Ein guter Punkt, svenson.
Aber letztlich sind es ja genau so Funktionalitäten wie WCF, WPF usw. die überhaupt eine Installation des Framework von mindestens Version 3 implizieren.

Wir werden uns einfach an die Vorgaben von MS halten, also SP2 des XP voraussetzen, und dann sollte es zu keinen Überraschungen kommen.

Ob man in Methoden jetzt :::

Mich würd interessieren, warum dir die Einheitlichkeit an dieser Stelle so wichtig ist. Es ist doch gehupst wie gedupst, was man verwendet.

Bei eigenen Klassennamesgebungen stimm ich dir 100% zu, alleine schon um gleich beim Lesen zu sehen, ob es sich um die Klasse MyThing oder eventuell um eine Variable myThing handelt. Aber bei string stört mich aber in keinster Weise ob ich da string oder String lese. Ist ja eh das Gleiche, und eins nur ein Alias für das Andere.

Vielleicht kannst du dir an diesem Beispiel etwas abkupfern.

Wenn das nur jeder Dienst so machen würde){gray}

Das würde aber implizieren, dass die DB für jeden Dienst genutzt wird, damit man dann zentral die ganzen Logfiles (bzw. Tabellen) hat. Die Struktur kann aber natürlich nicht vorgegeben werden, und somit bleibt eigentlich nur noch das wohl definierte Eventlog. Und deshalb kucken Admins immer zuerst dort hinein... Leider.

Nur mal so zur Vervollständigung, wie ich persönlich solche Sache halte:
Geloogt wird bei mir in ein DB. Dort hab ich dann Host und User des Clients mit als Information, natürlich die Zeit, und den Logtyp (Information, Warning, Error usw.). Das reicht aus, um schön zu filtern.
Fehler und Exceptions (als Logtyp Error) logge ich meist zusätzlich noch in das Eventlog rein, weil das meist die erste Anlaufstelle für Admins ist, um sich schlau zu machen. Zu diesem Zweck habe ich eine Messaging Klasse, an die ich unterschiedliche Loggingmechanismen anbinden kann. Darunter gehört zur Zeit DBLogging, Eventlog, Consoleausgabe, EMail Benachrichtigung und Popupfenster. Abschicken eines Logbefehls geht immer gleich. Abhängig vom Logtyp kann für jeden Logmechnismus angegeben werden, ob eine Ausgabe erfolgen soll oder nicht.

Ich befürchte, dass alleine schon der Versuch, aus einem Dienst heraus eine Konsoleausgabe zu machen, zu einer Exception führt. Zumindest musst du "Allow service to interact with desktop" auswählen. Bedenke aber die Sicherheitsrisiken.

Aber da du ja die Einträge eh schon in die DB schreibst, könntest du doch auch einen kleinen Client schreiben, der die Logs aus der DB ausliest und anzeigt.

Danke Khalid, genau eine solche Liste hab ich gesucht.

Bezüglich Service Pack kann ich bestätigen, dass es zumindest auf XP SP2 und SP3 funktioniert, SP1 haben wir hier nicht mehr rumfliegen.

Laut Khalid's Link ist SP2 des OS mindestens erforderlich. Wenn man das weiss, ist das aber kein Problem, sich danach zu richten.

Weiss jemand die spezifischen Anforderungen an ein Windows XP OS, damit das .NET 3.5 SP1 problemlos installiert werden kann. Bei Microsoft hab ich nur das gefunden, und das ist etwas dürftig.

Ich frage gezielt nach z.B. dem nötigen Patchlevel auf dem XP (reicht das Service Pack 1 des OS aus, oder muss 2 oder gar 3 drauf sein) und nach anderen Bedingungen (z.B. Microsoft Installer 3.1 oder höher?)

Der Grund ist, dass wir noch einige ältere XP Maschinen hier stehen haben, auf denen das 2.0 Framework einwandfrei läuft, aber die ich eigentlich jetzt auf 3.5 SP1 upgraden müsste. Jetzt befürchte ich allerdings, dass das an gewissen Dingen hängen könnte.

Die Rechner sind nicht mehr gard die neusten. Muss ich da Performanceverluste gegenüber .NET 2.0 Anwendungen befürchten. Denn wenn ich mir den Installer zum 3.5 SP1 anschaue, so hat der satte 237MB gegenüber 23MB bei .NET 2.0 (das ist eine Grössenordnung mehr... Was wird denn da alles noch mit installiert)?

Hat da jemand passende Links zu, wo ich mich schlauer lesen kann? Konnte selbst bislang nicht viel finden.

Bist du auf das XML Format verpflichtet. Alternativ und abhängig von der Komplexität der Daten, reciht auch ein CSV völlig aus. Kleiner wird die Datei dadurch auch noch.

Ich denke, das wird schwierig, da so Dinge wie Remoting und WCF rein für .NET ist. Ich befürchte, du wirst um eine eigene Schnittstelle nicht rumkommen. Wenn beide Prozesse auf einer Maschine laufen, könntest du eventuell versuchen, Windows Messages auszutauschen, oder über Named Pipes gehen. Ansonsten bleibt noch die nackte Socket Programmierung.