Wir selber setzen eigentlich auch nur noch WCF ein. Und von oversized und unperformant konnte ich bis heute nichts feststellen...

Dito... Und in unserem Umfeld bewegen wir uns nur innerhalb von 2 trusted Domains, und da kriegt man die Sicherheit einfach mal so ohne weiteres Zutun durch ein geeignetes Binding geschenkt.

Nur mal so als Hausnummer: Ich habe erste Performance Tests mit WCF und dem TCP Binding mal gemacht gehabt, und ich hatte Werte von unter 4 ms / Request. Und diese 4 ms beinhalten Verschlüsselung, Serialisierung, Deserialisierung, Netzwerkverbindung... Ok, der Server musste in der Tat nicht viel tun, aber dennoch finde ich 4 ms mehr als akzeptabel. Noch schneller sind vielleicht nur noch direkte Sockets, aber die erschweren einem aber wesentlich das Leben, nur um nochmal eine ms irgendwo rauszuholen.

dass es ähnlich oversized und unperformant wie Remoting ist.

Was gibts denn als performantere und weniger oversized Alternative, in deinen Augen (mit gleichwertiger Sicherheit)

Welchen Timer des Frameworks benutzt du genau, und welches Pollinterval hast du angegeben?

Na ob er das darf oder nicht, bestimmt die Application, aber ich müsste es halt vom SQL-User her dürfen.

Das würde ja heissen, jeder DB User hat ausreichende Rechte, um administrative Tätigkeiten durchzuführen.
Frage: Was hindert den User daran, sich mit einem x-beliebigen Query Tool am Sql Server anzumelden und dort z.B. ein drop Database durchzuführen, oder z.B. das Passwort vom sa-User zu verändern?

Allgemein ist es tatsächlich fast unmöglich, ausreichende Sicherheit alleine in eine Userauthentifizierung zu legen. Auf DB Ebene kannst du z.B. ledigliech einem Benutzer Rechte auf ganze Objekte geben (z.B. Tabelle, oder Tabellenspalten). Eine Diskriminierung auf Recordebene ist somit nicht möglich. Um auf Nummer sicher zu gehen, führt kein Weg um eine Middleware herum, denn nur dort kannst du deine Rechte granularer steuern. Der Benutzer selbst kriegt somit NIE direkt Zugriff auf die physische Datenbank. Vielleicht ist das doch mal eine Überlegung wert.

mich würde aber interessieren, wer WCF professionell einsätzt und was die Erfahrungen sind bzgl. Akzeptanz in der Industrie?

Aus meiner Sicht: hervorragend: Performant, Sicher, Stabil, Konfigurierbar... Auf jeden Fall klassischen Webservices vorzuziehen, in allen genannten Punkten.

Gibt es eine Möglichkeit die config auch in der DLL zu haben? Hier

Ehrlich gesagt, ist das der Hauptgrund für mich persönlich, warum ich diese ganzen .config Files nur meide wo ich kann.

Das wird u.U. nicht auf jedem x-beliebigen PC funktionieren wegen fehlenden Rechten nehm ich an.

Das Problem wird sein, wenn über einen PDF Drucker gedruckt wird (ob PrimoPDF oder FreePdf oder sonst einer), dass die druckende Applikation installiert sein muss. d.h., wenn du ein .docx Word Dokument nach PDF konvertieren willst, so wird Word 2007 auf dem PC installiert sein müssen. Wenn das nicht gewährleistet sein kann (z.B. allein schon aus Lizenzgründen), wird die Konvertierung nicht klappen können.

Es gibt jedoch für gewisse Formate mehr oder weniger hervorragende PDF Konverter. Für RTF nutze ich z.B. den hier. Klappt hervorragend, jedoch nur für RTF Dateien.

JAck30lena hat es doch jetzt ein paar mal erwähnt. Du brauchst die Config Datei innerhalb deiner Anwendung, und nicht innerhalb der DLL. Die Config Datei der DLL wird ignoriert, und du hast nur eine: Die deiner Applikation.

Übrigens greifst du nicht über Webservice auf deinen Service zu, sonder über WCF. Das hättest du auch gleich sagen können.

1. Die Anwendung ist zwar klein, kommt aber nicht immer mit der SQL-Express Variante aus, und dann wird nach Usern Lizenziert. Wenn ich alle USer in der DB anlege wird das heftig teuer.

Genau kenne ich das Lizenzmodell nicht vom SQL Server, aber wenn das eine Einschränkung mit der Anzahl der User ist, ist das Vorgehen, jeden Anwender einzeln in der DB als User anzulegen tatsächlich nicht so sehr praktikabel.

Du hast dann aber noch definitiv die Wahl, eine Middleware einzubauen. Die User authentifizieren sich dann an der Middleware, und die Userlogik läuft dort ab. d.h. nur die Middleware greift physisch auf die DB zu, und kann somit mit einem einzigen Benutzer funktionieren. Aber ich geh mal davon aus, das alles auf die Schnelle umzustellen, ist wohl auch keine Lösung.

2. Wenn ich die DB zu uns ins Haus hole zu Wartungszwecken, kann ich mich natürlich erstmal mit keinem dieser User anmelden, da mein Server die User der DB nicht kennt.

Und? Das soll ja im Prinzip auch so sein.

3. Jeden User, den ich in der Applikation anlege, muss ich ja in der DB auch anlegen, löschen, Passwort ändern, usw. Das meinste ich mit Umständlich, oder gehe ich die Sache nur falsch an.

Die Benutzerverwaltung im SQL Server IST deine einzige benutzerverwaltung. Eine andere brauchst du eigentlich nicht. Meine damit, warum solltest du noch zusätzlich deine Benutzer sonstwo in einer Tabelle pflegen.

Wie ist das mit Passwörtern, ich melde mich an der Application an, dann habe ich ein Username und ein Passwort, die User stehen aber in einer Tabelle in der DB, also baue ich einen Connectionstring mit Username & Passwd und versuche die DB zu öffnen, oder?

Im Connectionstring übergibts du Benutzernamen und Passwort, so wie der User sie in deinem Loginscreen eintippt. Damit öffnest du die Datenbank. Sind die Informationen falsch, fliegt dir eine Exception um die Ohren, mit dem Grund "Du kommst hier nicht rein".
Wenn du wirklich deine User noch zusätzlich in einer Tabelle brauchst (zum Verlinken z.b. aus anderen Tabellen), so lies die Information doch einfach mit dem Select aus. Ich verstehe nicht ganz das Problem an dieser Stelle.

Hi Florian,

danke für die Ausführung.

Aber um den sicheren Weg zu nehmen geht eigentlich eh nix an einer korrekten SQL Server Authentifizierung vorbei.

@Timo: du hast erwähnt, eine korrekte Benutzerverwaltung direkt im SQL Server wär zu fehleranfällig und zeitaufraubend. Infwiefern?

Du hast, die Rechte vorausgesetzt, eigentlich alle Prozeduren im T-SQL zur Verfügung, um neue Benutzer anzulegen und dessen Passwörter festzulegen. (z.B. sp_addlogin).

Hierfür kannst du das folgende Statement verwenden:

SELECT * FROM sys.dm_exec_sessions WHERE session_id = @@SPID;  

Mal eine Frage hierzu. Wie verhält sich denn die SessionId, wenn die Connection vom Client her geschlossen wird. Denn so solls ja sein, weil über ConnectionPooling ein erneutes Öffnen einer Connection dann keine grossen Resourcen verbraucht. Bleibt jetzt durch das ConnectionPooling die SessionId erhalten, oder wird diese trotzdem erneuert?

Kann ich der SQLConnection nicht irgend einen Wert mitgeben, der den User angibt, die der Trigger auselesen kann?

Den Benutzernamen direkt kannst du nicht angeben. Aber den Namen der Applikation. Dort kannst du unter Umständen ja dann den Benutzernamen ablegen.

Den Namen der Applikation kriegst du ja dann wieder im SQL Server ausgelesen.

Häng mal einfach an deinen ConnectionString ein APP=meinUser ran.

Erlaube mir aber noch die Bemerkung, dass diese Art von Datensicherheit dem Anwender nur etwas vorgaukelt. Besser wäre in der Tat, direkt mit konkreten Usern aus der Datenbank zu arbeiten, da du dann auc wirklich das Problem an der Wurzel packst, da der Anwender nichst manipulieren kann

Ich komme auch aus der Delphi Ecke, und kann eventuell ein paar Dinge zu deinen Punkten sagen:

1. In welchem Zeitraum kann ich meine Aufgabe realisieren. Spare ich Zeit.

Ich bin, zumindest bei etwas umfangreicheren Projekten, mit .NET wesentlich schneller unterwegs. Allein schon die IDE des VS mag ein Grund dafür sein, da Intellisense wesentlich besser funktioniert als unter Delphi. Aber auch so bietet das Framework bereits eine Menge an Klassen und funktionalitäten, die im grundpaket von Delphi einfach fehlen (z.B. generische Klassen möchte ich nie wieder missen). Insgesamt hab ich den Eindruck, dass das Framework wesentlich besser organisiert ist die Delphi Bibliotheken. Wenn ich z.B. einfach mal nur eine Liste von Strings sortieren will, so reicht einfach ein list.Sort() aus. Und wenn nicht, definier ich mir meine eigene Compare Methode, und ich kann sortieren wie ich will. Solche alltäglichen Dinge sind einfach nur sehr bequem unter .NET.

2. Welche Unterstützung finde ich bei einem Problem im Internet.

Naja, für C# hast du ja schon ein geeignetes Forum gefunden. Für Delphi kann ich dir wirklich Delphi Praxis ans Herz legen. Ich war dort selbst ein paar Jahre als Moderator unterwegs. Dort findest du eigentlich zu fast jeder Frage eine Antwort.

3. Was ist der Nutzeffekt für den Kunden. (Höherer Gebrauchswert)

Also was der Kunde sieht, ist ja im Prinzip erstmal nur eine graphische Oberfläche. Zumindest unter Winforms ist diese allerdings im Vergleich zu Delphi wesentlich träger. Und Geschäftsanwendungen werden nunmal noch immer vorzugsweise mit Winforms gestaltet und nicht über WPF. Ob WPF performanter ist, ist zudem noch eine andere Frage. Aufwändiger ist es auf jeden Fall.

4. Wie ist die Wartbarkeit, Modularisierung und Update.

Hängt natürlich sehr von deiner Programmierweise ab. Aber wenn du dich an Design Patterns hältst, bist du eigentlich in beiden Sprachen gut bedient. Letztlich sind beide ja auch nur OO Sprachen, sie können sich also schon per Definition nur unwesentlich unterscheiden.

Die Ereignisse MouseDown, MouseUp und MouseMove des Labels sind deine Freunde...

Ich möchter gern, dass mein C# Programm zu einer bestimmten Uhrzeit, die während der Laufzeit des Programms ermittelt wird, wieder gestartet wird.

Die Variante über die geplanten Tasks ist besonders empfehlenswert

Wenn ich das richtig verstanden habe, soll die laufende Instanz dabei aber noch zuerst beendet werden, oder? Das wird dann mit dem Taskplaner etwas schwieriger.

Ich habe ein datenbankbasiertes zentrale Rechtefirma hier bei uns. Die Benutzer werden z.B. über Windows Authentifizierung erkannt (Domain bezogen). Am WCF Server lese ich mir den Benutzerlogin aus dem Context aus, und lade dessen Rechteliste aus der Datenbank. Das Ganze gewrappt in einer eigenen Klasse, und es reicht anschliessend aus in der ersten Zeile der Methode am Server ein EnsurePolicy aufzurufen, mit dem zu überprüfendem Recht als Paramater. Besitzt der Benutzer diese Recht nicht, wird eine FaultException geschmissen, die zum Client durchgereicht wird.

Also ehrlich... Kennst du Google... Gleich der erste Treffer:
Schau mal

Ich möchte die aber von Platte laden.

Vielleicht ist das hier bei CodeProject eine Lösung. Habs aber noch nicht getestet.

Es ist niemand mehr bereit für Arbeit Geld auszugeben und das habe ich anhand diesen Projekt sehr deutlich zu spüren bekommen. Gebe ich nun noch die Sourcen frei so kommt es mir noch viel mehr wie ein "verschenken" meiner Arbeit vor. Aber das ist nur meine persönliche Haltung zu diesem Thema, dass ich eine Abneigung habe diese Jahrelange Arbeit einfach zu verschenken. Ich dachte dass diese Leistung die ich erbracht habe irgendwem wenigstens 5€ wert gewesen wären so dass ich mir für das Opfern meiner Freizeit mal Abends ein Bier leisten kann

Das kann ich so nicht auf mir sitzen lassen, sorry.

Ich mag es vielleicht in einem der unzähligen Einträgen in diesem Thread übersehen haben, aber mir ist jedenfalls nicht bewusst aufgefallen, dass du in irgendeiner Form jemals nach einer finanziellen Entschädigung gefragt hättest. Und paschal zu behaupten, dass die Leute kein Geld mehr für Lizenzen ausgeben, stimmt sicherlich auch nicht. Aber wenn du etwas für frei rausgibst, und darüber hinaus indirekt hier im Forum verlangst, die Mitglieder sollten bitte die Software auf Herz und Nieren testen, damit sie nachher den Ansprüchen auch gerecht wird, dann finde ich es imho schon fast dreist, diesen Leuten, die ja schliesslich auch Zeit investiert haben, zu sagen, du würdest das Projekt einstellen, weil keiner dir was für deine Arbeit zahlt. Ich kann nur von mir reden, und von mir hast du zumindest mal die Idee der Impersonifizierung, und den Quellcode (also nicht bloss die DLL) hast du von mir auch gerkriegt und ja auch in die letzte Version mit eingebracht.

Ich hatte damit kein Problem, da es dem Projekt an sich allgemein zugute kam.

manch einer nutzt es ja sogar innerhalb von Firmen und verdient indirekt damit Geld). Immerhin habe ich für das Projekt mein USBSynC geopfert und hatte selbst überhaupt keinen Nutzen vom AppDater

Hmm. Dann hast du imho was falsch gemacht: Entweder hättest du von Anfang das Programm als Shareware rausgeben können, oder aber keine kommerziellen Komponenten dafür einsetzen sollen. Jetzt aber zu lamentieren, dass du Geld in das Projekt reingesteckt hast, und nichts davon hast weil dir kein was für zurückzahlt, ist nicht das Problem der Anwender, sorry.

Versteh mich nicht falsch. Ich kann absolut nachvollziehen, dass du das Projekt aus Zeit- oder persönlichen Gründen nicht weiter pushen willst. Du hast deine Gründe genannt, und die akzeptier ich: Fehlen von Motivation, Suche nach anderen Projekten die dir mehr Spass machen usw. Dass manche in der Tat nur neue Funktionalitäten fordern, ohne eigenen Einsatz mitzubringen, darin kann ich dich schon verstehen. Aber bitte wälze darüber hinaus nicht ein Verschulden auf die Tester und Nutzer deiner Software ab. Das kann ich so nicht befürworten.

Über WCF wäre sowas relativ einfach über einen Duplexchannel realisierbar. Da du aber von einer Java Middleware redest, fällt das wohl für dich aus. Falls du den Server aber auch auf .NET unter Windows portieren kannst, wäre WCF über diese Callbackcontracts sicherlich eine Überlegung wert.

Denen die diese Software noch weiter verwenden wünsche ich dass alles glatt läuft.

Ich nutze diese Software intensivst, und habe auch keine Probleme damit. Es sind lediglich ein paar Punkte die nocht nicht implementiert sind.

Ich finde es schade, dass du die Zeit nicht mehr findest, das Dingen weiterzuentwickeln, kanns aber sehr gut nachvollziehen, da es mir bei zumindest einem Projekt auch so gegangen ist: Rema.

Von meinem Rema weiss ich, dass es noch weiter genutzt wird, auch wenn ich keine Updates mehr rausbringe. Ich denke, bei deinem AppDater wird es nicht anders sein. Das belibt dann sicherlich trotzdem eine positive Bestätigung für deine Arbeit.

Also ich weiss nicht nach welchen Begriffen du gegoogelt hast, aber mein erster Treffer war Viewing CHM Files Across The Network.

Ich kenn noch PostGres.

PostGres ist sicherlich ausgereift. Persönlich mag ich PostGres aber nicht so sehr. Ich empfand es als ziemlich langsam und schwer zu warten. In grösseren Systemen würde ich auf andere Datenbanken ausweichen, zumal ich micht noch nicht so wirklich mit der OO Struktur in einer Datenbank anfreunden konnte oder wollte.

Solange du in der foreach-Schleife hängst, wirst du sowieso keinen ButtonKlick abfangen können, es sei denn du arbeitest in der Schleife mit ekeligen und langsamen Application.ProcessMessages.

Ich denke eleganter löst du dein Problem indem du auf einen separaten Thread ausweichst. Am einfachsten und schnellsten, und ich denke für deinen Fall auch ausreichend, wäre die Verwendung der BackgroundWorker Klasse.

Es handelt sich bei dem eingesetzten GPS tatsächlich um ein hochgenaues DGPS System. Eingesetzt wirds im Motorsportbereich, Geschwindigkeiten von 360km/h sind also nicht ganz ausgeschlossen 😃

Ok, dann scheinst du ja wirklich 10 Millionen Datensätze in 3 Stunden messen zu wollen... Das ist eine ganze Menge, und ich denke das bedarf einer etwas klügeren Speicherung, als einfach nur Datensatz für Datensatz in eine Datenbank zu schaufeln. Ich denke gerade bei embedded Datenbanken stösst du da sehr schnell an Performancegrenzen, denn immerhin wirst du noch knapp 1000 Datensätze pro Sekunde schreiben müssen. Das klappt vielleicht noch am Anfang, wenn die DB noch klein ist, aber wird wesentlich langsamer, wenn du erstmal ein paar hundertausend Datensätze drin hast, zumal wenn noch einige Indizes auf deinen Tabellen liegen.

Ich bezweifele als, ob überhaupt irgendeine Datenbank auf einem kleinen Desktoprechner sowas überhaupt bewältigen kann.

Bei den Daten handelt es sich um Einträge mit mehreren Parametern. Bei GPS Daten besteht ein Eintrag z.B. Aus :
Zeitstempel,Position X, Position Y, Geschwindigkeit und Richtung

...

Wenn ich rechne, daß die Erfassungsrate meines Loggers bei ca. 20Hz liegt

Ich weiss ja jetzt nicht, ob du von normalen GPS Empfängern sprichst, oder ob du da was ultra hochauflösendes hast... Bei normalen GPS Empfängern hast du bestenfalls eine bestmögliche Ortsauflösung von +/- 10m (sehr optimistischer Wert). Wenn du also mit 20 Hz misst, solltest du dich in einer 1/20 Sekunde also schon um mindestens die halbe Strecke, also 5 m bewegen, damit eine so hoch frequente Messung überhaupt gerechtfertigt ist. Und 5 m in 1/20 Sekunde bedeutet 100 m/s, bzw. 360 km/h...

Also wenn du nicht gerad Flugzeuge oder Gewehrkugeln verfolgst, würde ich mir ernsthaft nochmal die 20 Hz überdenken.

ich sollte besser suchen das nächste Mal

>

Genau so wie in diesem Link beschrieben würde ich es gerade nicht machen, zumindest nicht so wie im oberen Abschnitt der "Tags" beschrieben. Der SQL Server ist eine relationale Datenbank, und d.h. man setzt Datensätze in Relation zu anderen, und versucht nicht alles auf "Teufel komm raus" in eine Tabelle zu packen.

Der Aufbau für deine Stichwortsuche wären folgende Tabellen:*Titel *Stichwort *Titelstichwort

Die Stichwort Tabelle Einträge sollen auch nur einmal vorkommen. Das Verknüpfen der Titel (Relation) geschieht über die Titelstichwort Tabelle.

Du solltest dich wirklich mal eingehend mit Datenbankaufbau beschäftigen, und nicht einfach munter drauf losprogrammieren um dir dann später im Projekt unter Umständen alles zu verbauen.

Das wird dann dort im Projekt geregelt. Oder gibts da auch noch irgendwelche tollen Möglichkeiten das über die AD zu regeln?

Das sollte imho auch so sein. Sinnvoll ist immer ein Rollenkonzept zu implementieren, d.h. ein User wird einer oder mehreren Rollen zugeteilt, und erbt somit die jeweiligen einzelnen Rechte jeder Rolle. An jeder Rolle können dann wieder mehrere Rechte haften. Das Rollenprinzip hat den Vorteil, dass du nicht jedem Benutzer immer alle nötigen Rechten einzeln zuweisen musst, was gerade im Bezug auf Wartung sehr sinnvoll ist. Wenn du das Ganze in einer Datenbank wartest, reichen dir Tabellen wie User, Role, UserRole, Policy und RolePolicy aus, um diese Verbindungen herzustellen.

Über AD direkt würde ich sowas nicht lösen, da es dafür nicht konzipiert ist. Du könntest zwar die AD Gruppen als eine Art Rolle betrachten, und die Usermitgliedschaft daraufhin prüfen, aber du kannst keine individuellen Rechte an eine Gruppe hängen. Darüber hinaus ist das AD auch noch verschachtelt (Gruppen können in Gruppen enthalten sein): das könnte zwar für ein Rechtesystem auch interessant sein, aber da musst du dann höllisch darauf achten, die Rechteüberprüfung rekursiv durchzuführen. Nach meiner Erfahrung verkompliziert sowas lediglich das Ganze, und benötigt hab ich es bislang auch noch nicht.

Löse es wohl mit einer separaten Applikation welche den aktuellen Status einer dritt Applikation an meinen Dienst sendet...

Steht dir der Quellcode der dritten Applikation, die überwacht werden soll, denn zu Verfügung. Denn wenn ja, kannst du auch dort in einem separatem Thread irgendwelche peridischen Aktionen durchführen, um nach aussen hin mitzuteilen, dass die Applikation noch lebt.

bei einem kleinem WebProjekt soll die Zugriffsteuerung über die Active Directorygeregelt werden.

Sei dir bewusst, dass diese Zugriff natürlich innerhalb der Domain funktioniert. Über Internet hast du so keine Chance, den Anwender zu authentifizieren.

Wenn du IIS nutzt, kannst du die DirectorySecurity für das virtuelle Web anpassen, und z.B. einfach nur einer AD-Gruppe Recht geben. Ist der authentifizierte Domain User in der Gruppe im AD definiert, kriegt er Zugriff... ganz analog zu den Dateiberechtigungen unter Windows.

Wenn das Rechtesystem allerdings über das Prinzip hinausgehen soll, ob der Benutzer Zugriff haben soll oder nicht, kommst du mit AD allein wohl nicht ganz weit.

Poste doch mal ein Diagrammschema der Tabellenstruktur, damit ich mal klarer seh, wie das alles in Beziehung zueinander steht

Dann müsste ich mich aber selbst darum kümmern, wenn sich in der Tabelle1 der Wert im Feld ändert

Ich glaube, genau DA liegt ein Denkfehler deinerseits vor. Cascading Updates bedeutet in deinem Fall nicht, wenn sich der Wert in Tabelle1 ändern, dass dann der Wert in Tabelle2 + 3 mit geupdated werden soll. Es ist genau die andere Richtung zu verstehen. Ein Update vom Primary Key Feld in Tabelle2 (oder Tabelle3) würde bei Cascading Updates alle referierenden Datensätze aus Tabelle1 anpassen.

Bsp.: In einer Tabelle Artikel gibt es einen Artikel mit einer ArtikelId 4911. Eine andere Tabelle Rechnung referenziert auf diesen Artikel 4911 indem in Spalte ArtikelId die 4911 steht. Ein Update der ArtikelId IN DER ARTIKEL Tabelle auf 0815, würde bei Cascading Updates alle Records in Tabelle Rechnung, die auf die alte ArtikelId 4711 referenzieren updaten, indem der Wert durch 0815 ersetzt wird.

Ich erstelle meine Berichte zu vollster Zufriedenheit mit TEkRtf. Ist einfach, und auch super schnell. Deine Berichtvorlage erstellst du einfach in Word und speicherst sie als RTF ab.

Dann kommst du schwer um ein Zertifikat herum, wenn du wirklich eine verschlüsselte Verbindung brauchst.

Um ehrlich zu sein, hab ich bislang die Sache mit den Zertifkaten auch noch nie zum Laufen gebracht.

Für wen soll dein WCF Server denn erreichbar sein... Ist er z.B. nur für Domänenmitglieder verfügbar, so kanns du alternativ auch clientCredentialType auf "Windows" setzen. Das erspart dir die ganze Zertifktatgeschicht. Zertifikate sind echt immer ein ziemlicher Aufwand, schwer zu konfigurieren und zu warten.

Es wurde doch schon weiter oben im Thread geschrieben, dass man Tabpages nicht einfach ausblenden kann.

Deine Art aus der Tabelle zu lesen finde ich übrigens äusserst unüblich. Diese ganze Hin- und Herkonvertierung sind allzu gut, und das Zugreifen über den Spaltenindex ist auch sehr schnell mal Ursache von Fehlern die du später nicht so leicht findest. Deshalb, besser die Spaltennamen wählen und auch geeignete Datentypen für deine Spalten wählen... Flexibel für spätere Änderungen ist dein Code auch nicht unbedingt.

Sehe ich das richtig:
Du hast eine Tabelle Berechtigungen mit 3 Spalten. Und für jeden Benutzer gibt es dann mehrere Einträge mit unterschiedlichen Werten in der Funktion-Spalte, und Angabe in der Berechtigungs-Spalte ob der Benutzer die Funktion besitzt oder nicht?

ich denke das geht dann doch ein bisschen einfacher ^^

Du kannst natürlich auch gleich die Rechte einem User zuordnen. Dann brauchst du nur 3 Tabellen (User, Policy, UserPolicy). Wenn aber einige Rechte sind, die du verwalten möchtest, würd ich trotzdem das Rollenkonzept nehmen. Zumal wenn mal ein User hinzukommt, musst du alle Rechte für diesen Benutzer wieder pflegen. Mit dem Rollenprinzip ordnest du lediglich den neuen Benutzer einer Roll zu (1 Record) und fertig.

Vom Aufwand her ist das ja nix weltbewegendes, und der PoliyCheck machst du mit einer einzigen Select Abfrage über mehrer Joins in deiner Datenbank.

Das könnte man ja über eine Tabelle in einer Datenbank machen.

Ich denke, du brauchst eine Art Rollenkonzept. Einer Rolle ordnest du Applikationsrechte zu (n:m Beziehung), und deine User legst du in verschiedene Rollen (n:m Beziehung). Wenn also schon Datenbank, so wirst du mit einer Tabelle also wohl kaum auskommen, du brauchst mindestens: User, Role, UserRole, Policy, RolePolicy

Leg dir eine Klasse User an, über die du dir dann die eigentlichen Rechte lädst, mit einer Methode CheckPolicy o.ä. über die du dann ein bestimmtes Rech prüfst.

Das Ganze ist allerdings mit einer 2-Tier Architektur (Gui Client und Datenbank) nicht sicher zu bekommen, da ein direkter Zugriff auf die Datenbank stattfindet. Besser wäre in einem kritischen System die ganze Logik in eine Middleware auszulagern, in der dann auch die Rechtprüfung abläuft. Da hat ein Client dann keinen Einfluss mehr drauf, und er kriegt höchstens eine Exception um die Ohren genknallt, wenn er versucht eine nicht erlaubt Methode aufzurufen.

Du musst deine interne Liste deiner cAndereKlassen von aussen zugänglich machen, d.h. sie public deklarieren. Wenn die Eigenschaft deiner inneren Liste z.B. MeineListe heisst, so greifst du so von aussen drauf zu:

cAndereKlassen.MeineListe[1].MalBunt;

Aber mal noch ein paar Bemerkungen dazu:*Die Indizierung beginnt immer bei 0, und nicht bei 1 *cAndereKlassen ist in deinem Fall wohl eher eine Instanz einer Klasse, und nicht die Klasse selbst *Wie ist denn deine innere Liste definiert: Welcher Datentyp?

Für deinen Fall bietet sich der DataContractSerializer von WCF an. Gibts aber erst ab .NET 3.0:

Wobei in dem Fall der DataContract als IsReference markiert wird, wenn ich mich recht erinnere 🤔

[DataContract(IsReference=true)]

Hallo Herbovore,

zum Verlauf der Diskussion muss ich gestehen, dass mir einige Posts entgangen sind, die sich während meinem Verfassen aufsummiert haben. Ich kenne aber zweifellos auch den Sinn und Umgang mit Singletons, und dass das natürlich nicht für alle möglichen Anforderungen verwendet werden soll. Nur, so wie ich den Anfangspost verstanden habe, war Rede von einigen Anfangsinitialisierungen, um Werte in einige Objekte zu schreiben. Und das klingt für mich nach dem SingletonPattern als Lösung. Aber nachdem ich mir die restlichen Posts hier durchgelesen habe, ist die Übergabe der benötigten Objekte als Parameter sicherlich besser geeignet.

singelton ist hier falsch meiner meinung!

Ich denke schon, dass Singleton deine Lösung ist. Beim ersten Zugriff darauf wird diese automatisch initialisiert, d.h. dessen privater Konstruktor wird aufgerufen. An dieser Stelle kanns du dir dann deine Eigenschaften der Klasse mit Daten füllen, die du dir von links und rechts holen kannst. Da eine Singleton immer nur einmal initialisiert wird, fällt dieses Datenfüllen auch nur einmal an.

Besser vielleicht sogar eine Mailingliste... Dann können sich die Clients selbst eintragen und auch wieder austragen.

Man könnte aber auch Linked Server verwenden. Dann braucht man gar keine "Daten hin und her schieberei", sondern kopiert die Daten direkt vom Server A auf Server B per UPDATE oder INSERT oder was weis ich.

Ich dachte, er hätte nur ein altes Backup?

Über Linked Server kann man problemlos sogar Cross-Server Aktionen durchführen. Dann fiele ein Restore natürlich ganz weg.

oder versteh ich das grad falsch?

Jupp, das verstehst du komplett falsch.

Die Dienste stellt der Server zur Verfügung (deshalb heisst das Ding ja Webservice). Über eine genormte Schnittstelle (z.B. Datenaustausch über SOAP) kann der Client dann Methoden aus dem Webservice aufrufen, und kriegt über SOAP seine Daten zurück.

Einen Webservice kannst du über viele Wege erstellen, entweder über .NET (wenn dein Hoster das unterstützt) oder auch PHP (auch hier muss dein Hoster PHP können).

Lies dich doch mal etwas in die ganze Thematik ein, dann verstehst du schnell wie das Ganze vom Prinzip her funktioniert.

Du musst die Dateinamen beim Restore anpassen, und zwar sowohl die .mdf wie die .ldf. Das geht aber eigentlich über das Management Studio... Ein Restorebefehl via Batch sieht in etwa so aus (musst du natürlich an deine Bedürfnisse anpassen):

RESTORE DATABASE [DBNAME] FROM  DISK = N'C:\Program Files\Microsoft SQL Server\MSSQL.1\MSSQL\Backup\MyBackup.bak' 
WITH  FILE = 5,  MOVE N'OriginalDB_Data' TO N'D:\sql_server\MSSQL\Data\DestinationDB_Data.mdf',  
MOVE N'OriginalDB_Log' TO N'C:\Program Files\Microsoft SQL Server\MSSQL\Data\DestinationDB_log.ldf',  NOUNLOAD,  REPLACE,  STATS = 10
GO

Vorsicht beim Restore... Du hast dir mal schnell eine DB so zerschossen.

Mach ein Restore der Datenbank in eine neue Datenbank rein. Dort hast du dann deine ursprüngliche Tabelle. Diese kopierst du dann mit Insert/Update zu deiner Original-DB. Cross-DB Updates sind kein Problem, du musst nur vor deinen Tabellennamen noch die DB und den Owner nennen, im Format:

Zieldatenbank.dbo.Zieltabelle

Probiers doch mal mit einem Timer für den Anfang.

Aber ich möchte nicht das man immer was drücken muss damit die methode immer läuft.

Ich glaube du denkst in die falsche Richtung. Was heisst denn, "eine Methode läuft immer" für dich?

Wenn sie immer läuft, bedeutet das erstmal dass du mittels einer Schleife in der Methode selbst diese nie beendet wird. Wenn dem aber so ist, so kommst du ohne Multithreading gar nicht mehr aus der Methode raus und kriegst somit auch keine Updates in der gui mehr hin.

Was du aber vermutlich meinst, ist dass in regelmäßigen Abständen deine Richbox aktualisiert werden soll... Dafür könntest du z.B. einen Timer verwenden, der in definierten Abständen einfach die RichBox refreshed.

Besser wäre allerdings eine direkt Benachrichtigung von deiner Scan Klasse selbst. Da ich die aber nicht kenne, kann man dazu auch nicht mehr sagen.