ich stehe im Moment vor folgender Aufgabenstellung:
Ich habe eine Anwendung, in lokale Konfigurationsdateien als XML vorliegen (teilweise einfach serialisierte Objekte, teilweise auch "selbst erstelles" XML).
Jetzt soll bzw. muss für die Konfigurationdateien ein Mechanismus eingebaut werden, der nur bestimmten Usern Änderungen erlaubt. Der "normale" Anwender soll die Anwendung nur benutzen können, die "Poweruser" sollen die Konfiguration auch ändern dürfen.
Über Windows-Dateiberechtigungen würde ich das ganze nur ungern lösen, da die Anwendung sehr oft installiert werden soll und bei jeder Installation die Anwender verschieden sind -> wird schnell unübersichtlich.
Da es keine weiteren Abstufungen im Berechtigungssystem gibt bzw. geben muss (also nur einen Teil der Konfiguration ändern etc.) hätte ich die Idee gehabt, die Konfigdateien verschlüsselt abzuspeichern. Problem dabei ist, dass ich das so machen müsste, dass die Anwendung selbst beim Start die Konfiguration immer lesen kann, also quasi einen "Generalschlüssel" hat. Zum Speichern / Ändern der Konfiguration müsste der Anwender dann ein Kennwort haben...
Leider weiß ich nicht, nach welchen Schlagwörtern ich hierzu suchen könnte aber hat evtl. jmd. von euch schon mal vor einer ähnlichen Aufgabe gestanden oder hat Tipps?
ich hab hier eine normale Windows-Anwendung (WinForms), die ein paar Konfigurationsdateien unterhalb von %ProgramData% liegen hat. Die Konfigdateien sind nicht anwenderspezifisch, die Konfig soll für jeden User, der den Rechner benutzt identisch sein.
==> Soweit kein Problem, wenn ich die Dateien gegen Veränderung sichern will - NTFS ReadOnly Rechte für User drauf und gut.
Jetzt kommt aber hinzu, dass bestimmte normale User die Konfiguration Ändern können sollen, andere wiederum nicht. NTFS-Rechte scheiden dann schon mal aus, weil man die sonst individuell pro Rechner konfigurieren müsste und außerdem z.T. Gruppenuser eingesetzt werden.
Was ich jetzt bräuchte ist ein Mechanismus, mit dem die Konfigdateien gesichert werden (also NTFS-mäßig zwar read/write-Rechte für User, aber dafür verschlüsselt), so dass die Anwendung die Dateien immer Lesen kann, aber dann nur nach korrekter Authentifizierung (per Passwort) wieder geschrieben werden können...
Gibt's da evtl. schon fertige Mechanismen für so was oder wie würdet ihr so was realisieren? Key / Passwort fest eincodieren ist jetzt eher nicht so mein Favorit, alles über AD machen / berechtigen würde in ziemlich hohen Verwaltungsaufwand ausarten.
Hast du evtl. die DiscardNull-Eigenschaft des verwendeten SerialPort-Objekts auf true gesetzt?
(MSDN)
Grundsätzlich ist vielleicht auch zu sagen, dass man im Internet sehr oft Hinweise drauf findet, dass die Implementierung der SerialPort-Klasse nicht grade optimal ist. Mich hat's bisher zum Glück noch nicht betroffen...
wir führen aktuell eine Diskussion zum Thema wie man Daten am besten abspeichern sollte / könnte um Sie dann möglichst performant abrufen / anzeigen zu können.
Aktuelle Situation:
In einer DB Tabelle werden Kopfdaten gespeichert, wobei es zusätzlich eine Spalte mit XML-Daten gibt, die dynamische Daten beinhalten (das Quellsystem schickt eine pro Datensatz variierende Anzahl an Attribut- / Wertepaaren mit).
Eig. wäre das ein Fall für eine NoSql SB gewesen, hatten wir aber leicht nicht zur Verfügung.
Wir laden die Daten in eine Clientanwendung und lösen da das XML dann auf, generieren also dynamisch Objekte die dann alle vorkommenden Spalten beinhalten.
Gegenvorschlag aktuell:
Wir erstellen zur Kopfdatentabelle eine Erweiterungstabelle mit gleichem Schlüssel und einer 1:1 Beziehung. Die Erweiterungstabelle soll dynamisch erweitert werden / sich selbst aufbauen, d.h. wenn ein noch unbekanntes Attribut daherkommt soll einfach eine Spalte angefügt werden.
Grund für die aktuelle Diskussion ist die Performance der GUI Anwendung, die die Daten anzeigt. Meiner Meinung nach würde ich lieber Aufwand in die Optimierung des Ladens der Daten stecken als die DB so wie beschrieben umzubauen... Sicher geht dann das Abrufen der Daten wahrscheinlich schneller aber es widerstrebt mir einfach eine Tabelle dynamisch sich selbst verändern zu lassen aufgrund der Daten, die reinkommen.
Was denkt ihr da? Gibt's da sachliche / fachliche Argumente für so was oder ist das "Ansichtssache"?
ich stehe aktuell vor der Aufgabe in einer SQL-Server Datenbank Daten aus einer weiteren Anwendung zu Auswertezwecken zur Verfügung zu stellen. Das reine Bereitstellen der Daten ist dabei ünerhaupt kein Problem.
Was ich aber bräuchte und mir noch fehlt ist ein möglichst einfach zu bedienenes Reportingtool, mit dem man auf Basis von SQL-Abfragen Reports erstellen kann (in tabellarischer und wenn mögich auch z.T. grafischer Form). Sachen wie die SQL Server Reporting Services sind für die Anwender dabei leider eher nicht geeignet.
Ich habe mir heute mal "Seal Reports" auf Github angesehen - sieht schon mal vielversprechend aus... Kennt jmd. von euch evtl. noch andere, ähnliche Tools ? (Auf Java-Basis gibts da ja einiges, aber aufgrund von div. Problemen mit Java Anwendungen und mangels geeignetem Webserver - die Tools sind ja oft auch webbasiert - habe ich mich eig. auf .Net als Runtime festgelegt)
Also wenn ich Webservices, die SAP direkt zur Verfügung stellt, in meine Anwendungen einbinde, dann läuft das so:
- Unsere SAP Entwickler erstellen einen RFC Baustein und generien in SAP einen entsprechenden Endpoint
- Ich kriege von den SAP Entwicklerm ein WSDL File, das die Definition des Webservices emthält (wird glaub ich aus einer Transaktion SOAMANAGER raus generiert aber ich hab mit SAP so leider nix am Hut ;))
- Das WSDL-File binde ich bei mir in Visual Studio ganz normal ein. Wichtig dabei ist, dass die Services wirklich SOAP Webservices und keine WCF Services sind (Deine config sieht mir nach WCF aus).
Wie's mit der Authentifizierung aussieht kann ich dir jetzt nicht sagen, das liegt dran ob ihr expliziten Login macht (Da kann der Username + PW via NetworkCredentials mitgegeben werden) oder irgendwas anderes (Denke da gibt's auch noch SAP Logon Tokens etc.)
Beim Aufruf der Webmethoden sind je nach Art der Parameter (Table, Import, Export, Changing) und der SAP Typen noch ein paar Sachen zu beachten (z.B. bzgl. Initialisierung von Strukturen vor dem Aufruf; Lustig wird's z.B. bei Date/Time Typen, da muss man die WSDL z.T. manuell anpassen bevor's funktioniert).
-> Wenn das ein wichtiges Projekt ist das drängt und du noch nie mit SAP Webservices gearbeitet hast wär's evtl. einfacher mit dem SAP .Net Connector 3.0 oder über ERPConnect direkt den RFC aufzurufen (Nachteil ist dann, dass der SAP GUI auf dem Client vorhanden sein muss bzw. die librfc32.dll + entprechende Einstellungen in ein paar Systemfiles).
Ein Tipp noch: Wenn der Webservice Aufruf mal grundaätzlich klappt aber z.B. auf SAP Seite nicht in die richtigen Typen konvertiert werden können ist die Transaktion SRT_UTIL eine gute Anlaufstelle.
Dann war ich ja schon mal gar nicht so falsch dran.. Quartz.Net schaue ich mir dann mal genauer an.. die Pipelines habe ich mir auch schon angesehen, allerdings hätte ich nicht mehrere hintereinandergeschaltete Pipelines...
Ich habe ja keine mehrstufige Verarbeitung sondern nur einmal das Laden der Stammdaten, die dann nicht weiter verarbeitet werden, und das Laden der Bewegungsdaten in verschiedenen Intervallen, die dann wirklich verarbeitet werden.
Da die geladenen Bewegungsdaten dann aber auf die gleiche Art und Weise verarbeitet werden bräuchte ich nur eine BlockingCollection, in die alle Bewegungsdaten geschrieben werden und aus der Sie dann zur Verarbeitung "entnommen" würden.
Hab ich das so richtig verstanden?
ich habe hier folgende Problemstellung:
Ein Hintergrunddienst soll sich aus einer (angenommen beliebigen) Datenquelle Stammdaten holen, die zur weiteren Datenverarbeitung benötigt werden.
Die Sätze dieser Stammdaten haben eine Eigenschaft, die sie in unterschiedliche Kategorien einteilt, die die weitere zeitliche Verarbeitung regeln. Außerdem sollen die Stammdaten in einem definierten Intervall neu eingelesen werden, damit Änderungen automatisch übernommen und berücksichtigt werden.
Grob gesagt gibt es Datensätze, die alle 1, 2, 5 oder 10 Minuten verarbeitet werden sollen.
Ich wäre jetzt folgendermaßen vorgegangen:
1. Zyklisch die Stammdaten in eine simple List<> einlesen
2. So viele Timer erstellen, wie ich verschiedene Intervalle habe.
3. Synchronisation der Stammdaten-List<> über ein Objekt, das ich per lock() während der Aktualisierung der Stammdaten sperre
4. Beim Ablauf eines Verarbeitungstimers ziehe ich mit aus der Liste der Stammdatenobjekte eine Kopie, die nur die für den aktuellen Timer relevanten Elemente enthält.
5. Die Timer sichere ich intern gegen "sich selbst überholen" ab.
Jetzt gibt es inzwischen aber ja schon neuere Möglichkeiten wie Tasks, Pipelines etc. mit denen ich aber noch nicht konkret gearbeitet habe.
Hat jemand evtl. eine Empfehlung für mich, wie ich so eine Aufgabe möglichst "sauber" realisieren könnte?
Hab mir auch schon Sachen wie Quartz.Net angesehen aber ich denke, dass das für meine Zwecke evtl. oversized ist...
ich beobachte hier bei mir aktuell folgendes Phänomen:
Wenn ich einen Anwendung aus VS heraus im Debug-Mode starte und eine einfache SQL Abfrage ausführe (Abfragen von Daten aus zwei Tabellen, die per Left Join verbunden sind), dann läuft die Abfrage relativ schnell durch.
Nehme ich aber das Ergebnis des Debug-Builds und starte die Anwendung ganz normal, dann habe ich auf einmal stark erhöhte Laufzeiten...
Kennt jemand einen Grund, warum sich eine Anwendung anders verhalten könnte, wenn Sie direkt aus VS heraus im Debug-Mode gestartet wurde?
mit dem Matlab Builder den vbprogger verlinkt hat, funktioniert das eigentlich ganz gut.
Meine Erfahrungen (mit einer Version von Matlab, die nicht mehr aktuell ist):
1. Das Erzeugen der notwendigen DLL(s) aus Matlab heraus funktioniert von Handling her relativ einfach.
2. Mit deiner Anwendung musst du normalerweise nicht das komplette Matlab deployen sondern nur eine Matlab-Runtime
3. Anscheinend unterstützt der Matlab Builder nicht alle Funktionen / Befehle, die Matlab zu bieten hat. Musste damals einiges umstellen / ausmisten, da selber erstellte Routinen, die diese Befehle verwendet hatten, einfach nicht mit in die DLL integriert wurde... Wie das damals genau war weiß ich leider nicht mehr - nur, dass ich da eine Zeit lang Logfiles gewälzt hab ;-)
4. Die Datentypen, die in der .NET DLL dann rausgekommen sind, waren teilweise etwas suspekt :-D vor allem bei Vektoren und Matritzen...
Also ich hab das mit der CLR Stored Procedure mal ausprobiert und zu meiner Überraschung war ich mit dieser Methode 3 langsamer als in der vorher erwähnten Methode 2. (43s vs. 33s bei ca. 25.000 Records mit 27 Spalten)
Jetzt habe ich dann noch eine Methode 4 realisiert:
Die Daten werden direkt als XML unverändert aus der DB in die Clientanwendung geladen (SqlReader) und die Daten per XDocument ausgelesen und in eine DataTable geschrieben, wobei die Attribute direkt als Spalten umgesetzt werden.
Damit bin ich jetzt bei ca. 2,6s für 25.000 Records a 27 Spalten.
Ich denke, dass die CLR SP wahrscheinlich schneller wäre, wenn der Code noch weiter optimiert würde (ist er nämlich im Test nicht gewesen).
Aber rein aufgrund des Geschwindigkeitsvergleichs und der Tatsache, dass ich keine zusätzliche DLL im SQL Server registrieren muss, werde ich schätzungsweise bei #4 bleiben und die Umsetzung der XML-Daten in das gewünschte Format im Client selbst realisieren. Was sich ganz gut trifft ist dabei, dass die Leute, die viele Daten laden, meist sehr leistungsfähige Rechner haben.
Ok ich hatte gedacht vielleicht ist das direkte Auslesen schneller aber der direkte Verleich zeigt:
- Methode 1: Dynamisches Query erstellen, bei dem jede Spalte durch einen XPath-Ausdruck definiert ist: 18s
- Methode 2: Alle Key-Value Paare rausladen und dann mit einem dynamischen Query pivotieren: 4s
Das ganze bei 3200 Rows mit je 27 Spalten / Attributen im XML... ganz schöner Hammer der Unterschied...
Dann werd ich das mit der CLR SP nochmal probieren - da muss ich mich aber erst mal schlau machen - hab ich bisher noch nie gebraucht.
Vielen Dank an der Stelle schon mal für die wirklich hilfreichen Tipps!
Die Option NoSql habe ich leider nicht - ich bin an einen SQL Server gebunden..
Die Sache mit dem XML-Spaltentypen habe ich mir angesehen und Testweise implementiert...
In den XML Spalten steht jetzt z.B. folgendes XML drin
D.h. pro Eigenschaft habe ich ein Element, das einen Namen und einen Wert hat.
Speichern ist der Daten ist relativ easy, beim rausziehen im richtigen Format hab ich noch etwas Probleme:
Ich will im Endeffekt eine Tabelle bekommen, die die Werte der Attribute NAME als Spaltennamen hat:
ATTRIB1 ATTRIB2 ATTRIB3
Wert1 2653 Test0815
Was ich jetzt gemacht habe ist erst mal alle Werte des Property NAME über alle Einträge rauszusuchen (DISTINCT)...
Mit diesen Spaltennamen habe ich mir dann dynamisch ein Query zusammengebaut, das mir dann die Daten in genau der richtigen Form ausgibt - allerdings denke ich nicht, dass das eine wirklich performante Lösung ist - es wird ja dann für jede Spalte ein XPath Query auf die Daten ausgeführt...
Habt ihr da vielleicht noch einen Tipp oder ein Stichwort für mich, wie ich es möglichst Performant schaffe, die Daten aus einer Struktur wie oben so auszugeben, dass ich ein Attribut für die Spaltennamen und ein anderes für die Werte verwende?
ich habe grade folgendes Problem: Ich designe eine Datenbank bzw. eine Applikation zur Anzeige der Daten, wobei ich mit "flexiblen" Datenstrukturen zu kämpfen habe.
Ich habe immer einen Basisdatensatz, zu dem es dann mehrere Attribute gibt, wobei ein Attribut immer ein paar aus Name und Wert ist. Da es nicht zu jedem Basisdatensatz das gleiche Set an Attributen gibt habe ich jetzt folgende DB-Struktur:
Basistabelle 1:n Zuordnungstabelle
Zuordnungstabelle 1 : n Attributname
Zuordnungstabelle 1 : n Attributwert
Sowohl die Namen kommen mehrfach vor als auch die Werte (sind teilweise vordefiniert).
Jetzt will ich die Daten aber in meiner Anwendung anzeigen lassen, wobei die Attribute zum Basisdatensatz aber einfach als zusätzliche Spalten angezeigt werden sollen. Dazu habe ich eine Stored Procedure geschrieben, die die Attribute transponiert und an die Datensätze aus der Basistabelle dranhängt. Die kann ich dann in mein Programm reinladen und direkt an ein DataGrid binden.
Das Problem ist jetzt, dass der ganze Vorgang relativ lange dauert, da ich teilweise 100000 Datensätze auf einmal lade.. bei 20 Attributen inkl. Werten dauert die ganze Sache mit dem Transponieren dann schon richtig lange.
Gibt es für so eine Problemstellung evtl. einen anderen Ansatz? Mir würde nur einfallen, statt der o.g. Struktur eine Datenbanktabelle dynamisch aufzubauen, d.h. die Attribute in einer eigenen Tabelle speichern, zu der nach Bedarf dynamisch Spalten hinzugefügt oder entfernt werden, und die dann einfach mit einer Beziehung
Basistabelle 1 : n Attributtabelle in der DB liegt.
Über Anregungen, wie man so was am besten designen kann / sollte, wäre ich sehr dankbar!
ein Problem mit der Tokengröße bei der Authentifizierung hatten wir auch mal, allerdings nicht in Zusammenhang mit dem IE / IIS sondern einer anderen Anwendung.
Benutzer mit mehr vielen Gruppen (meist die "wichtigen") konnten sich nicht mehr anmelden.
Abhilfe hat bei uns gebracht, die MaxTokenSize auf dem Server, an dem sich die Benutzer über die Anwendung anmelden wollten, hochzudrehen
Ob dazu vorher an den DCs eine Änderung notwendig ist kann ich leider nicht sagen - hab damals den Regkey auf den Max-Wert gesetzt - Reboot - geht bis heute einwandfrei.
Ich bin auf der Suche nach einer Bibliothek bzw. Komponente, mit der ich in einer Windows Forms Anwendung eine Art Zeichenbereich erstellen kann, auf die der Anwender dann per Drag and Drop Symbole ziehen kann... Eben ähnlich Micorosoft Visio..
Ich hab so was denke ich mal vor einiger Weile gesehen, nur leider kann ich mich an den Namen nicht mehr erinnern...
Hat jemand vielleicht einen Tipp für mich?
Vielen Dank!
ich habe hier auf einem Rechner einen ganz seltsamen Effekt:
Starte ich den Service unter dem Account LocalSystem, dann läuft alles normal. Starte ich ihn im Kontext eines Domainaccounts, dann kriege ich beim Starten einen Fehler 1053 (the service did not respond to the start or control request in a timely fashion) und der Service startet nicht.
Das Problem konnte ich schon eingrenzen:
- An den Anmeldeinformationen des Domainaccounts liegts nicht, da die Meldung über eine fehlerhafte Anmeldung schon vor dem Fehler 1053 kommen würde.
- An fehlenden referenzierten Bibliotheken liegt es auch nicht. Habe ein minimales Testprojekt erstellt, das ein leerer Windows Service mit einem Timer ist, der den akt. Zeitstempel in ein File schreibt
=> Wird der Service unter LocalSystem gestartet funktioniert alles wunderbar, wird er unter einem Domainaccount gestartet gibts einen Fehler 1053.
Hatte jemand evtl. schon mal so ein Problem? Oder weiß wer, wo ich am besten ansetzen könnte, um dem Fehler auf den Grund zu gehen?
das Stichwort ist schon mal sehr gut... danke!
An verschiedene Datenbanken hab ich auch schon gedacht, den Ansatz allerdings wieder verworfen, da ich aus einer GUI Anwendung heraus auf sämtliche Tabellensätze gleichzeitig zugreifen muss...
Wenn ich allerdings jetzt so drüber nachdenke, fallen mir doch einige Dinge ein, die dafür sprechen und keine wirklichen Probleme, die die dagegen sprechen... Danke für den Denkanstoß!
sorry für den vielleicht etwas unverständlichen Titel des Posts, aber hier mal eine Erklärung, was ich genau meine:
Ich habe mehrere Schnittstellen, die Daten in identischer Struktur liefern. Die Datenstruktur sieht so aus, es eine "Mastertabelle" M gibt, in der Basisinformationen enthalten sind. Dann gibts noch einige Tabellen, wo z.B. die Quelle Q des Datensatzes und das Ziel Z definiert ist. Diese Tabellen stehen in einer M : Q bzw M : Z = n : 1 Beziehung, d.h. Q und Z sind immer eindeutig und M referenziert auf diese Sätze.
Außerdem gibts dann noch Eigenschaften eines Mastersatzes, wobei nicht jeder Mastersatz die gleichen Eigenschaften hat. Daher gibt es eine Tabelle EN mit den Namen der Eigenschaften und EW mit den Werten der Eigenschaften. Diese Tabellen stehen mit der Mastertabelle über eine zwischengeschaltete Beziehungstabelle in Verbindung.
Jetzt würde ich gerne in der Datenbank unterscheiden, wo die Daten herkommen bzw. die Daten wirklich trennen. I.d.R. würde man ja einfach ein Feld im Masterdatensatz einfügen, und jeder Schnittstelle einen Wert zuweisen. Allerdings kommen über die Schnittstellen sehr viele Daten mit sehr vielen Eigenschaften (Verhältnis Master : Eigenschaft ca. 1 : 60), wodurch die Zuordnungstabelle entsprechend schnell groß wird, was komplexe Abfragen auf die Daten ziemlich verlangsamt. Außerdem muss ich die Daten regelmäßig archivieren, und evtl. unterschiedlich lange aufbewahren.
Wäre es in einem solchen Fall denkbar, mehrere "Tabellensätze" mit identischer Struktur in z.B. unterschiedlichen Schemen (oder gar Datenbanken?) anzulegen, und jede Datenquelle auf einen eigenen Tabellensatz schreiben zu lassen? Oder wenn nicht im gleichen Schema dann die Tabellensätze z.B. einem Prefix im Namen zu unterscheiden?
Gefühlsmäßig ist die Lösung mit Tabellensätzen nicht wirklich schön, aber im Prototypen funktioniert sie soweit sehr gut und ist durch die Trennung der Daten auch schön performant... Gibt's da irgendwelche Designregeln, die mir so was verbieten oder wie würdet ihr so was lösen?
ich bin auf der Suche nach Komponenten, mit denen ich folgendes machen kann:
Ich will ähnlich wie in Visio Shapes zeichnen und positionieren können, wobei ein Shape aber keine besondere Grafik sein muss sondern einfach ein "Block" sein kann.
Auf den Blöcken sollen dann Ein- und Ausgänge definiert sein. Über die GUI sollen dann Verbindungen zwischen den Blöcken hergestellt werden.
Als bestes Beispiel fällt mir der DataSet-Designer aus Visual Studio ein:
Zwei Tabellen erstellen, per Drag&Drop eine Beziehung aufziehen - fertig.
Kennt jemand vielleicht so was in der Art? (Am besten kostenlos)...
Werte an Queries übergebe ich sowieso grundsätzlich nur über Parameter...
Mit T4 habe ich mich bisher noch nicht beschäftigt. Sieht aber interessant aus... Vielen Dank für den Tipp!
keine Angst, meine TableAdapter werden schon richtig eingesetzt ... (sind durchaus sofern sinnvoll erweitert) ;-)
Warum nicht den SqlText dynamisch erzeugen? Weil FxCop was anderes sagt ;-) Scherz beiseite... Sql dynmaisch zu erzeugen ist selbstverständlich eine Lösung - für mich hat sich aber die Frage gestellt, ob man so was nicht irgendwie anders machen könnte...
Das mit den SP's steht leider erst mal nicht zur Debatte. Die sind an anderer Stelle u.a. aus Performancegründen vorgegeben. Sofern möglich sollte dann auch eine Mischung aus SP's und "normalen" Abfragen vermieden werden...
ich habe hier eine SQL Server 2008-Datenbank, in der sich einige Tabellen mit relativ vielen Spalten befinden. Aus diesem Tabellen möchte ich Datensätze selektieren, wobei bestimmte Kriterien immer angegeben werden müssen (z.B. Start- und Ende-Zeitstempel). Der Rest der Spalten (alles unterschiedliche Datentypen, von nvarchar bis bit...) soll optional mit Kriterien versehen werden können.
Habe ich z.B. eine Spalte Message, dann kann der Anwender dafür ein Selektionskriterium eingeben, muss aber nicht.
Ich verwende in meiner Anwendung typisierte DataSets und für die Abfragen StoredProcedures. Wie kriege ich es denn am besten hin, mit solchen optionalen Parametern zu arbeiten? Dadurch dass die Parameter optional sind, kriege ich ja eine riesen Anzahl an möglichen Parameterkombinationen zusammen.. Für jede Kombination eine Procedure zu erstellen kann ja nicht die Lösung sein, oder? Wie löst man so was denn elegant?
Angenommen eine Anwendung (Service) benötigt zum Zugriff auf ein System, das keine integrierte Windowsauthentifizierung unterstützt, Zugangsdaten. Diese müssen dem Service in irgendeiner Form bereitgestellt werden.
Den Ansatz, die Zugangsdaten mit einem eincodierten Passwort zu verschlüsseln, habe ich verworfen, da es ja Tools wie .Net Reflector oder ILSpy gibt, die trotz Obfuscator einige ungewollte Daten ans Licht bringen können.
Nächster Ansatz wäre es jetzt, die Daten mit der Klasse ProtectedData zu verschlüsseln. D.h. string in byte[] konvertieren, durch die Protect()-Methode jagen und lokal ablegen. Damit wären die verschlüsselten Daten nur an dem einen Rechner wieder entschlüsselbar und auch nur dann, wenn man einen zusätzlichen byte[] (optionalEntropy), der dann fest hinterlegt würde, kennt.
Kennt jemand Gründe, die gegen eine solche Umsetzung sprechen (Risiken, die ich nicht bedacht habe...)? Oder hat vielleicht jemand andere / bessere Ideen? Ich bin ja sicher nicht der erste, der vor diesem Problem steht ;-)
Über Anregungen wäre ich sehr dankbar!
P.S.: Mit der Crypto API von Windows habe ich schon gespielt, allerdings ist mir das ganze Handling zu umständlich (Außer es kennt jemand einen Wrapper für die Crypto API, der es einfach erlaubt Keys in einem Store zu speichern und wieder abzurufen - so was konnte ich bisher leider nicht in funktionsfähiger Form finden). CNG fällt auch flach, weil das ganze unter Windows XP auch noch laufen muss...
Ok danke erst mal für die interessanten Antworten...
Die Sache mit den Micro-ORM hört sich schon mal gut an - das seh ich mir auf jeden Fall an...
Untypisiertes Dataset steht leider nicht zur Debatte...
Eine auf Stored Procedures basierte Lösung zu verwenden wär mir aus Performancegründen eigentlich am liebsten, da die Tabellen relativ schnell mit vielen Daten befüllt werden und ich die I/O so gering wie möglich halten möchte/muss...
Bei den Inserts müssen außerdem noch Einträge in in Beziehung stehenden Tabellen erzeugt werden...
Da müsste ich ja wenn ich keine SPs verwende erst einen Aufruf zum Insert des eigentlichen Datensatzes machen und auf Basis der autogenerierten ID dann n zusätzliche Datensätze in der Zuordnungstabelle erzeugen... Das führt dann zu 1+n Inserts... In einer SP könnte ich das alles direkt nacheinander abwickeln....
Gibt's eine Möglichkeit außer über sp_execsql den Tabellennamen erst beim Aufruf einer SP festzulegen? Oder bliebe als letzter Ausweg (falls das mit dem Micro-ORM nichts ist) nur noch eine SP pro Tabelle anzulegen?
In einer MS SQL Server Datenbank existieren mehrere Tabellen, die exakt die gleiche Struktur haben und sich nur im Namen unterscheiden (ja, das muss leider so sein ;-)).
Wie setze ich den Zugriff auf diese Tabellen am besten um? Ich könnte mir im Programmcode natürlich die entsprechenden Statements dynamisch zusammenbauen und absetzen (per SqlCommand etc.), allerdings benötige ich typisierten Zugriff auf die Datenelemente.
1. Gedanke: Stored Procedure mit Tabellennamen als Parameter, SqlString zusammenbauen und mit sp_execsql ausführen. In meiner Anwendung habe ich das ganze dann als generische typisierte Tabelle.
2. Gedanke: Evtl. typ. DataSet und TableAdapter verwenden, allerdings fällt mir da jetzt nichts ein, wie ich den Tabellennamen in den Adaptern ändern könnte...
3. Gedanke: Gibts da evtl. Möglichkeiten mit Linq2Sql?
An so was in der Richtung hatte ich auch schon gedacht. Das Problem ist: Wie erkenne ich automatisch die Formatstrings, wenn ich sie nicht vordefinieren kann und will, weil sie sich ständig ändern können bzw. nicht meiner Kontrolle unterliegen? Die zu speichernden Nachrichten kommen aus einem Drittsystem und werden nicht vom Anwender des Programms verwaltet....
ich stehe aktuell vor der Aufgabe, dass eine Anwendung eine große Anzahl an Zeichenketten bekommen und diese möglichst platzsparend abspeichern soll.
Die Anwendung selbst ist ein einfacher Windows-Service, die Daten werden in einer SQL-Server Datenbank gespeichert.
Die Zeichenketten, die beim Service eintreffen, können n unterschiedlichen Mustern folgen, z.B.:
Nachricht: XXX: 21
Systemnachricht: 16
...
Viele Nachrichten sind dabei gleich aufgebaut, d.h. Sie haben feste Bestandsteile in einer festen Reihenfolge, wobei zwischen die festen auch variable Bestandsteile eingestreut sind.
Was ich jetzt gerne erreichen würde wäre, die variablen Bestandteile zu erkennen. Damit könnte ich den "festen Teil" in einer Tabelle als Template speichern und in der eigentlichen Eingangstabelle würde dann nur das Template referenziert + die variablen Werte abgelegt.
Gibt es hierfür so was wie ein "Entwurfsmuster" oder eine allgemeine herangehensweise? Hat jemand evtl. einen Ansatz, wie man da am geschicktesten rangeht? Danke!