Forenbeiträge von Unfug Ingesamt 133 Beiträge
Schande über mein Haupt.
Habe es jetzt gerade getestet.
http://localhost:5000/api/Test/?Age=0&Name=huu
Es wird tatsächlich automatisch geparst.
Das ist großartig.
Habt vielen Dank.
Hallo Unfug,
wieso? Du hast Parameter, die du entgegennimmst. Das sind keine Klassen, sondern strings oder Integers, etc.
...Ist ja im Prinzip nix andres. Nur, dass die Id ein bisschen einen Sonderstatus in der Schreibweise hat.
Ja. Ich wollte nicht verwirren. Das mit den Filtern habe ich auch so verstanden und umgesetzt.
Ursprünglich war ja die Idee, dass ich so etwas wie OData Alternative gesucht habe. Wo ich komplexe Filteranfragen als Request übergeben kann, weil OData noch nicht mit .NET Core läuft.
Eine Lösung wäre gewesen, dass man es so umsetzt wie @Abt angegeben, indem man ein komplexes QueryObjekt übergibt.
Dies widerspricht aber scheinbar der Rest Get üblichen Vorgehensweise.
Danke für alle Antworten bzgl. dieses Themas. Ich habe noch eine andere Frage bzgl. Versioning. Aber dafür mache ich gleich am Besten ein neuen Thread auf, weil es ja doch ein anderes Thema ist.
Schöne Grüße
Unfug
Guten Morgen,
Vielen Dank für eure Antworten und Links. Lese ich mir gerade durch.
Wenn der Body "leer" bleibt, wie kann ich denn dann wie im Beispiel von @Abt das machen?
public IActionResult Get(PersonQueryOptions query = null)
Das wäre doch dann eigentlich nicht möglich für ein Get, wenn wir konform bleiben möchten.
@Der Ultimate guide : Super Link! Danke
Das klingt echt gut.
ExpressionBuilder kenne ich gar nicht. Aber die Vorgehensweise klingt echt vernünftig.
Bzgl. HttpGet.
Ich übertrage doch ein komplexes Datenobjekt. Dafür bräuchte ich ja den Body vom Request. Ich bin es eigentlich gewohnt bei HttpGet den Body immer leer zu lassen, weil z.B. auch Postman das direkt ausgraut bei Get-Aufrufe.
Du verwendest den dann einfach?
Danke.
Ich hatte auch gerade nochmal intensiv gesucht und hab dabei folgende Definition gefunden:
Ressourcen über Segmente ggfs auch über eindeutige ID Ressource/Id und Eigenschaften über Querys.
Deine Aussage entspricht dem. Bei deinem Aufbau setzt es voraus, dass ich mir ein QueryModel baue. Für jedes komplexe Objekt dann ein eigenes QueryModel. Solch ein Model kann ich aber schlecht über HttpGet verwenden, dafür bräuchte ich ja schon ein HttPost.
Würdest Du dann komplexe mögliche Anfrage so aufbauen?:
public IActionResult Get(string age = null, string color=null, string whatever=null)
Und dann im Code überprüfen ob was !=null ist?
Oder gibt es eine "saubere" Lösung (abgesehen von odata).
Hallo mycsharp,
Angenommen ich habe das Objekt
Person
{
Alter,
Haarfarbe,
Größe
}
Wenn ich jetzt eine Rest API dafür erstellen würde, wäre das in etwa so
[HttpGet]
public IActionResult Get()
{
return AllePersonen
}
[HttpGet("{Alter"})
public IActionResult GetByAlter(int Alter)
{
return AllePersonen(Alter);
}
[HttpGet("{Haarfarbe"})
public IActionResult GetByAlter(string Haarfarbe)
{
return AllePersonen(Haarfarbe);
}
Meine Frage ist: Wie kann ich am Besten diese Queries "dynamisch machen", so dass ich nicht alle Abfragevarianten implementieren/definieren muss?
Ich habe nämlich ein Objekt, dass wesentlich komplexer ist als das obrige Personobjekt und brauche hier unterschiedlichste Abfrage Varianten. Auch in Kombination (hier: Alter und Haarfarbe).
Gewünscht wäre sowas:
[HttpGet({dynamischerQuery})]
public IActionResult Get(Query dynamischerQuery)
{
return AllePersonen(dynamischerQuery)
}
Im "alten ASP WebAPI" konnte man OData verwenden. Einerseits gibt es das noch nicht für .net core anderseits höre ich immer wieder von vielen Bugs von Leuten, die das intensiv nutzen. Viele sagen es ist der falsche Weg, aber eine Lösung konnte mir noch keiner aufsagen.
Oder würdet ihr auf dynamische Queries verzichten? Falls ja? Warum?
Danke
Unfug
+1 Git
Nutze 2 Branches
Produktiv
Development
Alles andere /Forks/weitere Branches muss der jeweilige Mitentwickler entscheiden und nach Absprache kann das gemerged werden. Ist aber zunächst nur lokal
Ich nutzte nur TortoiseGit über das Kontextmenü.
Komme damit äußerst gut klar. Wichtig ist jedoch auch klare Ansagen, wer für was in dem Projekt verantwortlich ist.
@zoomi
Danke für den SourceTree Link. Kannte das Prog noch nicht. Sieht nett aus.
Interessant.
Bei mir kommt nur Error Object reference not set to an instance of an object.
Und der Designer wird dann nicht angezeigt. Deine Meldung kriege ich aber nicht.
<Window.DataContext>
<vm:ViewModel></vm:ViewModel>
</Window.DataContext>
Aber ohne die Änderungen klappt es? Ich hatte das DataContext = new ViewModel in den CodeBehind gepackt, weil bei mir sonst der Designer rumgesponnen hat.
Update: was ist eigentlich C:\Users\Account2\Downloads\WpfApplication3\WpfApplication3\packages\Prism
.4.1.0.0\lib\NET40\Microsoft.Practices.Prism.dll'?
Die habe ich gar nicht eingebunden. Nur die MVVM
Hallo zusammen,
inzwischen bin ich etwas weitergekommen. Ich wollte mal euer Feedback einholen.
Ich werde die Solution anhängen, um darüber zu diskutieren.
Folgender Aufbau:
Klassen
Car [Stellt das Model dar]
CommandMap [ist die CommandMap jedoch abgehändert - dazu gleich mehr]
ViewModel [ist der DataContext für das WPF. Alle Models kommen hier als Variable rein]
MainWindow [WPF]
In der CommandMap gibt es zu der Version von FZelle folgende Änderungen:
Statt predicates werden Func<bool> für canExecute übergeben
Statt ICommands werden DelegateCommands verwendet.
Warum habe ich letzteres gemacht? (Der alte Code steht kommentiert noch drin)
Antwort:
public event EventHandler CanExecuteChanged
{
add { CommandManager.RequerySuggested += value; }
remove { CommandManager.RequerySuggested -= value; }
}
Dieser Bereich führt dazu, dass bei jedem Klick, egal wohin, die canExecuteChanged Methode ausgeführt wird. Das ist natürlich absolut unschön, dass ständig etwas gefeuert wird.
In diesem Video von Channel 9 geht der Entwickler genau darauf ein und setzt aus diesem Grund das von Prism umgesetze DelegateCommand ein.
Dies habe ich daher entsprechend auch gemacht. Dadurch wird tatsächlich nur dann das canExecuteChanged ausgeführt, wenn man es auch irgendwo "gefeuert" hat.
Weiterhin habe ich die folgende Methode hinzugefügt:
public void RaiseCanExecuteChanged(string commandName=null)
{
if (commandName == null)
{
foreach (DelegateCommand item in Commands.Values)
{
item.RaiseCanExecuteChanged();
}
return;
}
Commands[commandName].RaiseCanExecuteChanged();
}
Dies war notwendig, damit ich dann in dem ViewModel auch ein RaiseCanExecuteChanged durchführen kann.
Sollte ich ein konkreten Namen übergeben, so wird auch nur die entsprechende canExecuteChanged Methode für das bestimmte Command gefeuert.
Soweit funktioniert auch alles und entspricht auf UI Ebene meinen Vorstellungen, wann etwas aktivierbar ist und wann nicht.
Jetzt habe ich folgende Fragen:
Wenn ich das so umsetze, dann hätte ich bei vielen Model-Klassen eine Vielzahl an Properties und Instanzen im ViewModel. Weiterhin würde jeder Button, jede Listbox, jedes Control eine Methode in der selben Klasse haben. Ist das korrekt so? Und generell freue ich mich über Diskussionen darüber, ob die Änderungen sinnig sind.
Ich füge die Solution als Zip an.
Gruß
Hallo Ezio,
nein Du hast schon recht soweit bzgl. WPF.
Es existiert in meiner Programmierung eine klare strikte Trennung von UI, BL und DAL. Es ist also bisher auch kein Problem die UI direkt auszutauschen oder DAL oder die BL. Alles ist soweit in Ordnung und funktioniert wie es funktionieren muss.
Somit hast Du Recht mit der Aussage "Da liegt ja (...)", da ich aufgrund meiner eigenen Implementierung nicht direkt ICommand genutzt habe. Ich muss zugeben, dass mir das Konzept auch nicht bisher so bekannt war, weil die Ebene UI/WPF von mir Stiefmütterlich bisher behandelt wurde. Bin mehr in der tieferen Ebene Zuhause.
Ich habe jetzt schon bisschen mehr gelesen und ja, es löst sogar das Problem, dass ich gehabt hatte mit den Laufzeitfehlern.
Zum Beispiel: Eine Collection wird nur angebunden, wenn eine Vorbedingung erfüllt ist.
Ich werde definitiv mich jetzt damit auseinander setzen und es einbauen.
Gruß
Hallo Fzelle,
ja ist richtig.
Ich nutze derzeit kein MVVM mittels bekannter Frameworks, sondern habe eine eigene Implementierung.
UI ist nicht so meine Expertise, jedoch hatte ich festgestellt, dass meine Programmierung sich ähnelt mit den ganzen Frameworks. Ein VM existiert somit, jedoch nicht auf die Art und Weise, dass es für WPF optimiert ist (ICommand).
In der Code Behind Datei sind im Prinzip nur Weiterleitungen und keine BusinessLogik.
Obwohl WPF diese netten Sachen wie DataBinding per XAML erlaubt, muss ich zugeben, dass ich diese ungern nutze. Die Möglichkeit einiges erst zur Laufzeit zu testen schreckt mich manchmal ab.
Die Geschichte mit den Controls wird mich aber dazu führen, dass ich mich damit nochmal (extra für die Windows Variante) beschäftigen muss.
Aufjedenfall vielen Dank für die Tipps und Tricks. Ich werde mich demnächst damit auseinandersetzen. Das ist fest eingeplant.
Ich würde mich natürlich freuen, wenn Du über deine Variante der CommandMap noch mehr schreiben könntest. Möglicherweise hast Du ja schon irgendwo ein Blogeintrag?!
Gruß
Update: ThomasE:
Ja da habt ihr Recht. Werde ich definitiv machen. Manchmal läuft einem einfach nur die Zeit davon 😁
Ja genau ThomasE.
Allerdings nur auf die UI bezogen.
Ich habe soetwas schonmal in einer C Anwendung gesehen. Dort gab es eine Konfigurationsdatei in der tatsächlich diese Abhängigkeiten drin standen. Und man konnte es zur Laufzeit ändern. Das ist natürlich schon Jahrzehnte her und ich denke, dass dort irgendeine große Logik mitprogrammiert wurde, so dass das funktioniert.
Da ich viele Dialoge in der Anwendung habe, deren Controls vom Context abgängig (Aktueller Status, was wurde vorher geklickt), wäre sowas natürlich schön zu zentralisieren, damit ich das besser managen kann.
Ich musste leider noch in den letzten Tagen an einer anderen Baustelle arbeiten. Werde aber in 1-2 Wochen mich dann intensiv mit dieser CommandMap mal beschäftigen.
Gruß
Danke nochmal.
Die Idee mit der Konfigdatei bezog sich darauf, dass man von "außen" dies steuern könnte ohne den Code extra neu zu kompilieren.
Wie eine klassische Konfig eigentlich, nur halt für die UI. Wahrscheinlich war es einfach zu lange her, dass ich mit WPF was gemacht habe. Ich werde mir diese CommandBinding und RelayCommands näher anschauen.
Sieht ja relativ einfach aus. Vor allendingen diese CommandMap von FZelle sah äußerst interessant aus. So bleibt, meiner Meinung nach, der Code auch recht sauber.
Danke für die Antworten.
Ich lese mir das gerade mal durch.
Sowohl auf msdn als auch Codeproject (link).
Ist aufjedenfall eine interessante Vorgehensweise.
Habt ihr denn vielleicht auch schonmal versucht, solch eine Logik zu extrahieren? Sprich in eine externe Text/Config Datei? Ich fände das äußerst nett. Sowohl während der Programmierung mit anderen Kollegen als auch für weitere Dinge (Bereiche (Schein-)sperren).
Gruß
Hallo mycsharp,
Ich habe eine GUI (WPF), die eine Vielzahl an "Buttons" hat.
Beim Starten der Anwendung ist noch nichts geladen und ein Großteil müsste deaktiviert werden.
Genauso müsste sobald etwas in der Anwendung geladen wurde, die Buttons aktiviert werden.
Übliche Vorgehensweise wäre die Abhängigkeit in Code umzusetzen.
Beispielhaft:
if (aktiv)
{
Button1.Enabled= true;
Button2.Enabled= true;
}
else
{
Button1.Enabled = false;
}
Persönlich finde ich das ziemlich unschön. Gibt es vielleicht die Möglichkeit, dass man bei WPF diese Abhängigkeiten in eine Art XML Konfigurationsdatei schreibt und WPF diese auswertet?
Vielleicht sowas?
[Datei geladen]
[AktiveButtons]
Button1
Button2
Button3
[InaktiveButtons]
Button4
Button5
Ich hoffe ich habe es verständlich geschrieben. Auch für die weitere Entwicklung/Testen fände ich dies sehr gut, da ich so einige "Plugins" einfach ausgrauen könnte, damit man sich auf das Wesentliche fokussiert.
Hat jemand Tipps für mich?
Danke
Unfug
Um den Post etwas am Leben zu halten mal ein Nachtrag von mir.
Ich habe bisher keine Lösung für mein Problem gefunden. Nach wie vor Nutze ich ich die üblichen Tools und erstelle Policies mittels Hand.
Ich hatte zuletzt den Weg ala Code First ausprobiert. Zunächst hatte ich einen Webservice in .NET programmiert, der entsprechend gesichert war. Die generierte WSDL hätte ich ja theoretisch verteilen können.
Problem hier: .NET, Java und Co. sind dermassend inkompatibel was Security Features angeht, dass dies nicht hingehauen hat. Es macht absolut keinen Sinn.
Um den größten gemeinsamen Nenner (ich möchte ja so viel Sicherheit wie möglich) muss ich alles zunächst per Hand machen und regelmässig validieren.
Gruß
Unfug
Hallo mycsharp,
in einem aktuellen Projekt soll zunächst die WSDL/XSDs spezifziert werden.
Hierfür gibt es einige Tools wie Oxygen oder xmlspy, die einen untersützten. Das Problem ist, dass diese WSDLs mit WS-Security erweitert werden sollen. So soll z.B. nur die Kommunikation mit den Schnittstellen erlaubt sein, wenn ein entsprechendes X509 Zertifikat mitgesendet wird.
Das Problem ist jetzt, dass ich das bisher in Notepad alles machen musste und dies natürlich fehleranfällig ist und auch nicht validiert wird.
Hat jemand vielleicht Erfahrung mit WS-Security gemacht und kann seine Vorgehensweise berichten? Auch die eingesetzten Tools?
Gruß
Unfug
Hallo zusammen,
ich habe folgendes Problemchen.
Gegeben ist ein Security Token Service (STS), welcher ein SAML2 Token ausstellt.
Um das SAML2 Token zu erhalten, muss ich eine Request Message an den Service senden. Inhalt der Message ist Zertifikat.
Erstmal wollte ich mir Arbeit ersparen und nicht die XML Request Message selber zusammenprogrammieren, weswegen ich auf ein Framework setzen möchte. Gefunden habe ich WIF und WSE (obsolete).
Mit WIF bin ich überhaupt nicht klar gekommen. WIF verlinkt in die verschiedensten C#-Namespaces, dass man total durcheinander kommt. Auch Google spuckt nicht allzu viel aus, wenn man mal nach einem Fehler sucht, weswegen ich auf das veraltete WSE gegangen bin.
Ich habe jetzt das Problem, dass der STS Service fixe Prefixe verlangt. So sucht der Service zum Beispiel unter
S:Header/B:Body/X:RequestSecurityToken
das entsprechende Tag.
Die Frameworks (WIF und WSE) generieren jedoch nicht S, B und X als Prefixe, sondern irgendetwas anders.
Meine Frage ist:
a) Gibt es ein alternatives einfaches Framework für SAML2.0? Ich bin nur Client und will keinen eigenen STS aufbauen.
b) Wenn nicht, wie bekomme ich die Prefixe in S B und X? Oder muss ich mir tatsächlich das XML Request Dokument komplett selber bauen?
Danke Schön
Hallo Zusammen,
mir wurde vor kurzem die Möglichkeiten von Vaadin (eines Java Frameworks für Web Applicationen) gezeigt.
Mit Vaadin erhält man die Möglichkeit in normalen Java Code zu programmieren.
Wenn man nun seine Webanwendung deployed wird daraus Javascript und Co.
Man kommt somit nicht mehr mit JavaScript in Kontakt. Das ganze basiert wohl auf Googles GWT.
Es gibt wohl einige Einschränkungen, weil man auf das Framework beschränkt ist. Erweiterungen erfolgen dann von Version zu Version.
Die Anwendung von den Java Jungs ist wirklich großartig und als relativer Anfänger in ASP.NET Umfeld frage ich mich: Gibt es Empfehlungen für Server Side Controls Anbieter, die ähnliches anbieten?
Meine letzte ASP.NET MVC Anwendung war am Ende voll von JQuery Scripts. Verschiedenste Ajax Aufrufe an Controllern und um das klassiche HTML/CSS musste ich mich auch noch kümmern.
Telerik soll wohl so etwas anbieten http://www.kendoui.com/server-wrappers.aspx
Das werde ich auch mal ausprobieren (vielleicht heute noch).
Wäre aber über verschiedenste Meinungen und Empfehlungen dankbar.
Edit:
Worum es mir also geht ist in erster Linie nicht mit JavaScript in Kontakt zu kommen (ich mag das Zeug nicht selber machen) und die Möglichkeiten von .NET bzw. VS zu nutzen.
Gruß
Unfug
Fehlermeldung:
HRESULT: 0xFFFFFFF
Class: MeinComObject.MeineKlasse Method: ADD:, MSG: Copy file failed
Das wars auch schon.
Mahlzeit mycsharp,
Ich habe ein kleines Problemchen:
Ich habe eine externe Com Lib. Die auch registriert ist ( regsvr32 meinComObject.dll )
Ich habe ein VBScript (erstellt mit VBSedit32)
Set meinObject = CreateObject("meinComObject.MeineKlasse")
meinObject.Save(...)
Das VBScript läuft 1A durch. Keine Probleme bei der Ausführung und VBSEdit wurde auch nur mit User Rechten gestartet.
In Visual Studio 12 habe ich nun über "References --> COM" die ComLib ausgewählt, wodurch mir VS ja eine Interop generiert.
Mein einfacher C# Code sieht wie folgt aus
var meinObject = new meinComObject.MeineKlasse();
meinObject.Save(...)
Der Code läuft nicht durch, mit der Begründung das irgendwas nicht gespeichert werden kann. Die Fehlermeldung ist rudimentär ( Drittanbieter halt 😄 ).
Nach ein bisschen forschen habe ich herausgefunden, dass ich unter Windows 7 den Code explizit mit Adminrechten ausführen muss.
[Update 12:38h]
Soeben auch rausgefunden, dass wenn ich selbst die VBS Datei in eine EXE umwandel, dass ich Adminrechte benötige, um diese durchlaufen zu lassen.
Kann es sein, dass Scripte von Windows automatisch mit höheren Privilegien laufen?
[/Update]
Meine Frage daher:
Wie kann es sein, dass VBSEdit (ein Scriptprogramm) das ganze auch ohne Adminrechte ausführt, der C# Code jedoch nicht?
Irgendwie steh ich grad auf dem Schlauch.
Schönen Gruß
Bei mir funktionierte bei einer komplexen XSD nur folgendes Tool:
http://wscfblue.codeplex.com/
Vielleicht klappts damit
Vielen Dank für die Antwort. Ich hab es mir schon gedacht, dass es nicht anders geht.
Naja dann mach ich das Projekt "sauber" . Danke
Hallo Mycsharp,
ich stehe gerade vor folgender Situation (vereinfacht dargestellt):
Gegeben ist eine Klasse (Default) mit mehreren schon implementierten Methoden/Properties (normale und static).
public static int myStaticMethod () { }
public int myMethod() {}
public int myStaticVariable {get;set;}
public int myVariable {get;set;}
Jetzt sollen einige Methoden abgeändert werden für Kunde "Spezial". Beispielhaft die im oberen Code beschriebenen.
Es soll also eine neue Spezial Klasse erstellt werden, die den Gros an Funktionalität übernehmen soll. Ein kleiner Teil der Methoden muss aber kundenspezifisch angepasst werden und es sollen neue Methoden hinzukommen.
Also eigentlich Standardproblematik in der Softwareentwicklung. Jetzt existiert die Default Klasse aber schon und ist auch so im Einsatz. Der Wunsch ist also eine einfache Erweiterung, indem die Klasse Spezial implementiert wird. An einer einzigen Stelle später wird dann entschieden ob Default oder Spezial genutzt wird.
Meine ersten Überlegungen waren "Vererbung":
Ich benenn Methoden und Properties um, indem ich virtual davor setze. So kann die neue Spezial Klasse die Default Klasse erben und die entsprechenden Methoden überschreiben.
Problem sind jedoch die statischen Methoden/Variablen. Bei denen kann man nicht einfach virtual davor packen.
Da ich Zugriff auf die Default Klasse habe (Quellcode) könnte ich Änderungen vornehmen. Eine static Methode zu nonstatic zu machen, um dann virtual davor zu packen - ist allerdings mit sehr viel Arbeit verbunden. Einige Klassen nutzten nur die Static Methoden brauchen aber keine Instanz von Default.
Meine Frage an euch: Wie würdet ihr vorgehen?
Danke schön
Hallo Zusammen,
So die Diskussion ging schneller als erwartet.
Folgendes wollen wir zunächst weiterverfolgen:
Die Verbindungen zwischen
Framework -> DocumentAlpha
Framework -> DocumentBeta
werden gelöst indem sämtliche Abhängigkeiten, also verwendete Klassen aus dem Framework, gelöscht werden.
Da DocumentAlpha und Beta, wie hier schon richtig erkannt wurde eine Fascade darstellen, übernehmen wir die Klassen 1:1 aus dem Framework (Copy&Paste) und passen Sie, wenn möglich nochmal an.
DocumentBeta erbt DocumentAlpha und wird entsprechend erweitert. Das klappt (im ersten Test) scheinbar wohl ganz gut, wenn die Verbindung zum Framework gekappt ist.
Um die Verbindung nun zum Framework herstellen zu können, wird ein weiteres Projekt erstellt. Zunächst als Broker/Adapter programmiert übernimmt dieser Daten von Alpha, Beta und ersetzt gewisse Klassen dann durch die Klassen welche aus dem Framework kommen.
Es entsteht hierdurch mehr Code, mehr Redundanz.
Es ist vielleicht etwas "schmutzig" dies so zu realisieren. Nach außen sieht es allerdings konsistenter und sauber aus.
Übrigens hier auch in einem komplett eigenen Namespace (Framework.Services) und eigene Assembly.
Ich denke mit dieser Lösung haben wir zum Teil eure Vorschläge gut interpretiert.
Gruß
Wer immer die Klassen benutzt, wird sich doch vermutlich für ein Set von Klassen entscheiden, also entweder direkt die Originalklassen oder WrapperA oder WrapperB, aber keinen Mix daraus benutzen, oder nicht? Er wird also einfach die eine using-Direktive des einen Sets benutzten, das er verwenden will, und kleine Konflikte bekommen.
Das ist leider noch nicht der Fall. Derzeit müsste man beim Verwenden der WrapperA oder B Klasse sowohl ein using für die das Set der Originalklasse und ein Set der WrapperA Klasse einbinden.
Ich bin heute noch nicht dazu gekommen mir den Code vorzunehmen. Zeitlich sieht es grad auch wieder schwierig aus.
Nicht desto trotz, werden wir jetzt eure Hilfe einfließen lassen und mal schauen was wir noch retten können 😄
Ich meld mich hier aufjedenfall dann zurück, wie wir es dann nun schlussendlich realisiert haben.
Gruß
So wie ich das sehe ist dein Problem eher ein Bruch in der Architektur durch Änderungen an Klassen die ggf. auch durch externe Anwendungen weitergenutzt werden könnten.
Und du versuchst durch doppelte Klassen einen Bruch in deiner Software zu verhindern.
Ja so kann man es sehen.
Dies ist meiner Meinung keine saubere Lösung.
Mein Tipp wäre es die alte Klasse zu entfernen.
Doppelten Code pflegen macht keinen Sinn und ist kein schöner Stil.Wenn du aber diese Umsetzungen wegen externen Nutzung deines Frameworks so behalten musst hast du dir selbst schon keinen Gefallen getan und hast eine schlechte Architektur geplant.
Und dies wird dir dann zum Verhängnis.
Ansonsten solltest du dich wenn möglich nur von der alten Klasse trennen.
Da diese an sich ersetzt werden soll macht dies auch mehr Sinn.
Da das Framework fix ist, nehm ich jetzt zunächst mal den Rat an und gehe mit ein paar Kollegen nochmal die Architektur durch.
Nachtrag:
Falls du doch eine simple Relation machen willst, würde ich folgendes Vorschlagen.
Da sich beide Personen eine Eigeschaft Name teilen, kannst du hier eine Basis Klasse Person erstellen.
(...)
Das nehme ich mit in die Diskussion
Nachtrag 2:
Wenn du mit deiner Beta Framework Variante eine komplette Umstellung machen wilst, würde ich dir eher eine Versionierung mit SVN empfehlen und die Aufteilung in den Namespaces mit Beta/Alpha entfernen.Dies entspricht keiner sauberen Umsetzung aus meiner Sicht da ein Framework durch solche Sachen nur aufgebläht wird.
Der Code für eine Alpha oder Beta Version sollte immer in der entsprechenden Version vorliegen und nicht alle anderen Versionen enthalten.
Das Framework selbst ist fix. Da lässt sich nichts mehr dran ändern. Das stellt im Prinzip nur Datentypen bereit. Keine Funktionen oder dergleichen.
Diese Datentypen sind allerdings dermassend komplex, dass nur ein Profi (in dessen speziellen fachlichen Gebiet) damit umgehen kann. Daher wurde entschieden weitere Klassen zu generieren, die dem Nutzer der neuen Klassen (hier DokumentAlpha und DokumentBeta) nur das zur Verfügung stellt, was auch benötigt wird.
DokumentAlpha und Beta werden somit neu programmiert, nutzen dabei einige Datentypen aus dem Framework, andere Datentypen wurden neu geschrieben.
Dadurch habe ich in beiden Dokumenten die selben Klassennamen (wie z.B. Person).
Dies führt dann wiederum zu verwirrungen, wenn ich
DocumentBeta.Person = new Person()
mache, da verständlicherweise VS meckert es gäbe zwei Klassen von Typ Person. Somit habe ich bisher immer den Namespace mit angegeben. Das ist natürlich keine "saubere" Lösung.
Ich muss also verhindern, dass aus Beta auf die Alpha.DataTypes.Person zugegriffen werden kann. Weiterhin sollte aber Zugriff auf anderer Datentypen in diesem Namespace möglich sein.
Ich denke ihr habt recht - man muss die Architektur überdenken. Alles andere wäre wohl ein Customizing was nur noch viel mehr Stress später veursacht.
Ich nehme aufjedenfall eure Hilfe jetzt mit in die Diskussion.
Mal sehen was bei rumkommt.
Danke für eure Hilfe
Unfug
Mir ist noch immer nicht klar warum es zwei Klassen mit dem namen Person geben soll, du versuchst das gleiche Ding mit verschiedenen Klassen zu beschreiben ohne das diese in irgendeiner Vererbungshierarchie definiert sind.
Ja das stimmt
So wie du geschrieben hast klingt es als würdest du eine alte Klasse neu schreiben weil sie nicht mehr so wie früher verwendet werden kann
Auch richtig
Ich würde davon abraten mehrere Personenklassen ohne eine Relation zueinander zu haben da es nicht möglich ist zu sehen warum sich diese Unterscheiden.
Genau das ist einer der Probleme
Vor allem gibt der Namespace keine Information darüber was sich geändert hat oder wo welche Person zum Einsatz kommen soll.
Habe genau das Problem z.B. beim schreiben einer Foreach Anweisung
Ich würde generell noch einmal überdenken ob es nicht eine sinnvollere Möglichkeit gibt die Daten zu Organisieren.
Wenn die Namen jedoch so bleiben sollen bleibt dir sowieso nichts übrig außer mit Namspaces & Alias zu arbeiten.
Wenn ich die Daten umorganisieren soll. Meinst Du damit ich sollte lieber ein komplett anderen Namespace für DokumentAlpha und Beta nutzen?
Framework
MeineDokumente.DokumenAlpha
MeineDokumente.DokumentBeta
Und dann das Framework quasi referenzieren? So als wenn es eigenständige Projekte wären? - Wäre ein Überlegung wert. Es wurde halt alles in ein Namespace gepackt, da ich dachte das dies eigentlich der einfachere Weg ist.
Für kommende Arbeiten müsste man dann nur ein Namespace importieren und hätte alles. Das war die Idee dahinter warum alles in einem Namespace.
Hallo Zusammen,
Vielen Dank vorab.
Ja ist richtig. Es handelt sich um ein Beispiel. Die Namen sollen so erhalten bleiben, da diese so einleuchtend und selbsterklärend sind.
Macht es vielleicht Sinn die Datentypen in Framework zu ändern?
Die Ursache des Problem ist folgendes:
namespace Framework
{
public class Person
{
public String Name {get;set;}
public int GeschwisterAnzahl {get;set;}
public komplexObject Haarfarbe {get;set;}
}
public class komplexObject{}
}
In der Klasse DokumentAlpha dagegen muss der Aufbau der Person folgenden haben
namespace Framework.DokumentAlpha
{
public class Person
{
public String Name {get;set;}
public Color Haarfarbe {get;set;}
}
}
GeschwisterAnzahl darf von außen nicht mehr sichtbar sein und wurde deswegen entfernt. Haarfarbe war zuvor ein KomplexesObject was jetzt ein "einfaches" Color ist.
Vielleicht regt dies auch nochmal die Diskussion an.
Danke.
Hallo Zusammen,
ich hänge derzeit an einem architektonischen Problem, vielleicht hat jemand ein paar Tipps wie man es richtig macht.
Projekt1: Beinhaltet ganz viele Datentypen
namespace Framework
{
public class Person{}
public class Adresse{}
}
Projekt2: Beinhaltet ein Dokument, welches die Datentypen von oben nutzt, aber auch eigene hat, die den selben Namen wie oben besitzen
namespace Framework.DokumentAlpha
{
public class Dokument
{
public Framework.Person Vater;
public Framework.Adresse VaterAdresse;
public Framework.DokumentAlpha.DatenTypen.Person Mutter;
public Framework.DokumentAlpha.DatenTypen.Adresse MutterAdresse;
}
}
namespace Framework.DokumentAlpha.DatenTypen
{
// Gleiche Bezeichnung wie im Framework aber weiter unten im Namespace
public class Person{}
public class Adresse{}
}
Weiterhin exisitert eine weitere Klasse in dem Projekt 2. Diese Klasse erbt die Klasse DokumentAlpha. Zum Großteil werden die DatenTypen nur erweitert, aber auch Beta hat ein paar DatenTypen, die komplett umgeschrieben werden müssen. Für Beta ergibt sich daher folgendes:
namespace Framework.DokumentBeta
{
public class Dokument: DokumentAlpha //Achtung hier eine Vererbung
{
//Alphas Datentyp
public Framework.DokumentAlpha.DatenTypen Person
//Beta Datentyp
public Framework.DokumentBeta.Datentypen Adresse
}
}
namespace Framework.DokumentBeta.DatenTypen
{
public class Adresse{}
}
Und jetzt zu meiner Frage:
Wie gehe ich damit am besten um?
Ich habe mir Gedanken dazu gemacht wie mittels Zugriffsmodifier (private, public, protected, internal) das ganze sauber kapseln kann.
Oder die Namespaces anpasse.
Als Ergebnis kam raus, dass ich nicht weiß wie man es am besten macht, so dass man den Durchblick nicht verliert.
Ist es üblich den Namespace Namen (fully qualified name) wie oben zu verwenden? Wie kann ich sonst sauber trennen?
Danke für eure Tipps.
Hallo Zusammen,
diesmal geht es um einen WCF Rest Service.
Fall1 : SerializationException
Ich habe folgende Methode (beispielhaft):
[OperationContract]
[WebInvoke(UriTemplate = "/Person")]
void AddPerson(KlassePerson neuePerson);
Die KlassePerson ist einfach halber wie folgt definiert:
<Person>
<Name></Name>
</Person>
Wenn ich nun ein falschen XML Request sende
<PersonBUG>
<Name></Name>
</PersonBUG>
Dann wird eine SerialisationExeption geworfen, noch bevor **AddPerson **aufgerufen wird.
Meine Frage: Besteht die Möglichkeit hier den Fehler abzufangen und dann in einem LogFile zu schreiben - inkl. des XML Request?
Fall2 ist gelöst..siehe Update weiter unten
**Fall2: **Besteht generell die Möglichkeit POST Request (ich habe nur kleine XML POSTDaten) zu loggen, auch bei erfolgreicher Serialisierung, ohne den Umweg zu gehen in jeder Methode explizit etwas in ein LogFile zu schreiben?
Aktuell verwende ich
<source name="System.ServiceModel" switchValue="Information, ActivityTracing" propagateActivity="true">
...
<add name="xml" type="System.Diagnostics.XmlWriterTraceListener" initializeData="c:\log.svclog" />
hierbei werden allerdings keine Daten des Request-Bodys mitgeloggt.
Update:
Die PostDaten lassen sich wohl mittels IDispatchMessageInspector auslesen. Es werden somit alle "gültigen Aufrufe" inkl. PostDaten mitgeloggt. Das ist super, allerdngs auch sehr umständlich. Ich werde versuchen, dass ganze mal sauber zu implementieren, um hier zu posten.
Fall1 wäre aber noch offen 😉
Dankt euch und schönes Weekend
Hi,
wollte mich nochmal bedanken für die zusätzlichen Antworten.
Jede Menge Ideen, die ich erstmal durchgehen muss.
Habt vielen Dank.
Ich werde zunächst versuchen MrSparkle (bzw. Console32) Ansatz zu verwenden. Ich denke alles andere wäre dann doch zu Overkill.
Allerdings alles eine sehr interessante Geschichte bei so einem, so dachte ich zunächst, üblichen Problem 😄
Wie würde denn wie von MrSparkles Ansatz eine komplexe Anweisung aussehen?
Zum Beispiel:
IF ( (a == 1 && b >= 3) || (a ==2 && b < 1) ) DANN
Gruß & Danke
@Console32
Auf sowas bin ich gar nicht gekommen.
Allerdings wären komplexe If Anweisungen nachträglich nicht möglich, wenn ich diese nicht zuvor definiert hätte als ENUM.
Also Beispielsweise && || >> u.s.w. Also der Aufbau der IF Anweisung kann durchaus komplex werden.
@gfoidl:
Leider können die User, die das Programm benutzen nicht selber programmieren. Es sollte daher per Config angepasst werden. Daher fällt das PlugIn System raus.
Die Geschichte mit dem Parser dynamisch Code nachladen...klingt schon nach sehr viel Aufwand. Danach google ich aber mal
Hallo Zusammen,
mich beschäftigt derzeit folgende Frage:
Lassen sich IF Anweisungen über Config Dateien steuern?
Es geht um folgendes:
Ich füge Daten einer Datenbank hinzu, die zuvor von einer Methode geprüft werden:
IF Objekt.Zahl > 400 DANN FÜGE Objekt in die DATENBANK
Ich wüsste wie ich die **400 **in eine Config auslagere, aber nicht wie ich **> **auslagere.
Irgendwann könnte es z.B. auch sein, dass folgende Anweisung erfüllt sein müsste
IF Objekt.Name == Chef DANN FÜGE Objekt in die DATENBANK
Wünschenswert wäre es daher, dass man dies über eine Config Datei lösen kann, wann eine IF Anweisung erfüllt ist oder nicht.
Schönen Gruß
Unfug
Ein schönen guten Morgen an diesem Karfreitag,
ich habe eine Frage die mich derzeitig quält. Folgendes Szenario:
Ich habe eine Datenbank in der User hinterlegt sind. Weiterhin sind in der Datenbank Termine und andere Ereignisse von Usern hinterlegt, die sowohl in einem Kalender als auch in Charts dargestellt werden sollen.
Die Daten werden per RestFul Service bereitgestellt.
Als Ansicht soll nun eine Homepage realisiert werden. Ich habe mich für ASP.NET, bisher für MVC3, entschieden. Ein Umschwenken auf eine andere Technologie wäre allerdings noch kein Problem.
Auf der Homepage soll auf ...
... Seite 1: Die Liste aller User seien. Was kein Problem darstellt.
... Seite 2: Die Details des Users (Kalender ähnlich Outlook) und weitere Charts zu sehen sein.
Leider gibt es für MVC3 keine kostenlosen schöne Charts und keinen ordentlichen Kalender, daher habe ich mich für Javascript - genauer JQuery Flot und JQuery FullCalendar entschieden.
Aktuell ist es so, dass der Javascript Code direkt in der Seite cshtml drin steht, was das Ganze jedoch sehr unübersichtlich und fehleranfällig macht. Der Code führt meistens ein AJAX Aufruf zu einer ActionResult Methode auf, um von dieser JSON Daten zurückzubekommen.
Konkret sind meine Fragen:
- Macht es Sinn MVC3 zu nutzen? Oder sollte ich auf ASP.NET zurückgehen, um dort das Chart Control zu nutzen, um mir so etwas JavaScript Ärger zu ersparen.
Wäre dort die Verwendung von Javascript anders? - Wie sollte man vorgehen bei MVC3, wenn man Javascript nutz?
- Aktuell nutze ich den FullCalendar und lasse diesen einen AJAX Aufruf auf eine ActionResult Methode durchführen. In der Javascript Function für den FUllCalendar werden automatisch Start und EndDatum übertragen von JQuery. Diese Werte bräuchte ich auch für die anderen Charts, um die Achsen anzupassen. Aufgrund der AJAX Aufrufes sind diese Werte jedoch für die Charts immer Null. Wie kann ich sowas verhindern?
Vielen Dank und noch ein frohes Osterfest .
Super vielen Dank.
Das hat mir sehr geholfen.
Konkret sieht die Methode wie folgt aus & funktioniert
private List<TClass> ListOfObjects<TClass>(string MEINSTRING) where TClass: BasisObject
{
List<TClass> list = new List<TClass>();
using (...)
{
list = db.Query<TClass>().Where<TClass>(n => MEINSTRING.Equals(n.MEINPROPERTY)).ToList<TClass>();
}
return list;
}
Danke
Hallo mycsharp-User,
meine Frage richtet sich heute an Generic Methods.
Folgende Intention habe ich:
ich habe mehrere Methoden, die alle ein und die selbe Abfrage machen (LINQ) und mir jedes mal eine Liste von Objecten zurückliefern.
List = (from MEINTYPE o in db
where o.MEINPROPERTY.Equals(MEINSTRING)
select o).ToList<MEINTYPE>();
Der Typ MEINTYPE des Objectes ist jedoch immer unterschiedlich.
Jetzt hatte ich geplant diese Methode auszulagern und zwar in diese Richtung
private List<T> ListOfObjects<T>(T MEINTYPE, T MEINSTRING)
{
}
Leider stehe derzeit auf dem schlauch, weil ich nicht weiss wie die Query Abfrage aussehen muss. Der Compiler erkennt natürlich nicht, dass meine Objekte alle das Property MEINPROPERTY haben und meckert.
Ich hoffe man versteht was ich vor habe - vielleicht gibt es aber auch noch eine einfacheren Lösungsweg, den gleichen Abfragebefehl in eine eigenständige Methode zu packen, um so die "Wartung" zu verringern.
Danke
Hallo mycsharp Community,
ich bräuchte mal eure Hilfe bzgl. folgender Ausgangssituation:
Vorhanden ist ein WCF RestFul Service, der ganz einfach ohne irgendwelche Sicherheitsmechanismen implementiert ist.
Idee ist, den WCF RestFul im IIS zu hosten und den IIS die Clientauthentifzierung (ohne Active Directory) übernehmen zu lassen.
Also jeder, der das ausgestellte Client Zertifikat bekommt, darf auf den Service zugreifen.
Und ich hänge jetzt seit 2 Tagen daran, dass ich auf dem Entwicklungssystem (Windows 7, IIS 7.5) es nicht hinbekomme den IIS Client Zertifikate zu akzeptieren.
- Ich habe versucht mit MakeCert und OpenSSL(auf einem alternativen Rechner) mir einen CA, Server und Clientzertifikat auszustellen.
- Die Zertifikate in den lokalen Computer Zertifikatspeicher importiert.
- Das Client Zertifikat als Base64 exportiert
- Danach habe ich im IIS7 ein SelfSigned Certifcate erstellt und dieses in der Default Web Site über Bindings angebunden.
- Im Konfigurationsmanager von der Default Web Site habe ich den Base64 String des Client Zertifikat (als eine Zeile) bei One-To-One eingetragen.
Jedes mal, wenn ich jetzt die Webseite aufrufe, kommt die Meldung, dass die Webseite eine Clientauthentifzierung benötigt.
Nutze ich die OpenSSL Zertifikate kommt im Firefox die Meldung:
"Die angegebenen Anmeldeinformationen berechtigen Sie nicht, dieses Verzeichnis oder diese Seite anzuzeigen."
Meine Fragen sind:
- Hat jemand das schonmal auf einem DEV-System gemacht und kann mir helfen
- Ist der Ansatz, dass der IIS 7.5 die Aufgabe der Sicherheit übernimmt sinnvoll?
Vielen Dank (schönes Weekend noch)
Unfug
Hallo mycsharp,
Wer von euch kann mir Infos (Webseiten, Buchempfehlungen etc) zu Interface basierender Programmierung liefern?
Ich meine damit nicht den Weg Klassen nur als Interface zu deklarieren, um mehreren Entwicklern die Schnittstellen zur Verfügung zu stellen.
In einem Beispiel, ich weiß nicht ob es sich dabei um die oben genannte Technik handelt, habe ich gesehen, dass alle Klassen Interfaces waren.
Nur ein instanziertes Com-Object war vorhanden, welches dann verschiedenste Objekte mit Hilfe der Interfaces generiert hat.
Im Grunde bräuchte ich aber Infos von dem Grundgedanken der Architektur bis hin zu einer einfachen Realisierung.
Danke
UPDATE:
Wie M@TUK im zweiten Beitrag schon erwähnte: Dependency Injection ist scheinbar Zauberwort. Habt ihr dafür entsprechende Empfehlunge?
Danke
Ja, Du hattest Recht.
In den .cs Dateien findet man auch XML Kommentare, die dann noch eine .uex Datei laden.
Ich dachte es geht vielleicht einfacher.
Danke trotzdem.
Sobald ich im Objektkatalog z.b die Forms.Checkbox auswähle und dann noch als Ansicht Codedefinitionsfenster hinzufügen erhalte ich im temp die jeweilge cs Datei.
Öffne ich diese sind dort die Kommentare ohne XML Formatierung eingetragen.
Diese Art der Kommentare ist mir auch nur beim .NET Framework bekannt. Vielleicht hat Microsoft für die Intellisense ja noch eigene Dateien, so wie Sebastian geschrieben hat.
Hallo User,
kann man irgendwo in VS2010 einstellen, dass man statt der üblichen XML-Kommentare (Stichwort: <Summary>) den folgenden Stil verwenden kann?
//
// Zusammenfassung:
// Löst das System.Windows.Forms.Form.Activated-Ereignis aus.
//
// Parameter:
// e:
// Eine Instanz von System.EventArgs, die die Ereignisdaten enthält.
Im Objektkatalog werden mir sämtliche .NET Klassen mit solchen Kommentaren angezeigt. Auch automatisch generierter Code wird mit solchen Kommentaren versehen.
Nutze ich diese Art in meinen eigenen Klassen, werden die Kommentare nicht für IntelliSense verfügbar gemacht, was aber wichtig wäre.
Danke
Hallo Community,
ich fange gerade an mich in VSTO einzulesen.
Folgendes Vorhaben:
Beim Starten von "Beispiel.docx" erscheint ein WinForm, in welchem der User Werte eingibt. Beim Schließen der WinForm werden diese Werte in das Beispiel.docx übernommen. Die Datei wird ständig durch den User mit neuen Werten erweitert.
Das Problem was ich habe ist, wenn ich mit VS2010 nun ein Projekt Office-2010-Word2010-Dokument/Vorlage erstellt habe befinden sich im Release Ordner jede Menge Dateien.
beispiel.dll
beispiel.dll.manifest
biespiel.vsto
einige MS.OFFICE.TOOLS.***..dlls
beispiel.docx
Das Dokument soll jetzt nur an zwei, drei PCs verwendet werden. Wie sieht dabei die Verteilung aus? Ist es üblich den kompletten Inhalt auf einen USB Stick zu packen und auf den Rechnern zu kopieren? Und die User müssen dann die Beispiel.docx starten? Gegeben falls eine Verknüpfung auf dem Desktop anlegen?
Für eine Click Once Anwendung habe ich keinen IIS/Fileserver.
Bei VBA war ja der Code ja immer direkt im Dokument, wodurch die Verteilung unkompliziert war (einfach .docx auf den Desktop kopieren - fertig).
Oder sollte man VSTO Projekte so behandeln wie normale .NET Anwendungen? Also eigenes Programmverzeichnis in Programme, dann noch eine Verknüpfung im Startmenü zur *.docx
Danke für eure Erfahrungen
Unfug
Gelesen habe ich, dass man die Listen in ihrer Anzahl von Einträgen nicht limitieren kann.
Ich realisiere das aber erstmal so, mal sehen was Chefe dazu sagt.
Hallo Felix,
ich habe so jetzt das jetzt wie folgt (erstmal) realisiert:
Auf der TopLevel Site existiert eine Liste, die folgende Werte hat
[Projektname] [Projektverantwortlicher] [Status]
Beispielprojekt Herr Meier Nicht Begonnen
Beispielprojekt2 Frau Meier Begonnen
Hallöchen,
ich arbeite mich derzeit (berufsbedingt) in SharePoint2010 ein.
Idee ist es ein kleines Projektmanagement damit zu erstellen.
Als oberste TopLevel Webseite soll es eine Seite geben, die alle Projekte anzeigt mit einem Status (begonnen, nicht begonnen).
Die Projekte selbst (ich dachte da an eigene SubSites) sollen dann die Aufgaben, Mitarbeiter und Status verwalten.
Die Grundfunktionen von SharePoint2010, die quasi mitgeliefert werden, reichen meinen Chefs nicht aus. Optische Darstellung und Benutzerfreundlichkeit wäre nicht so gut. Der User soll sich wie auf einer Webseite fühlen.
Frage:
Als erstes möchte ich auf den SubSites, also den einzelnen Projekten, eine Variable setzen lassen: Begonnen, Nicht Begonnen (vom jeweiligen Projektleiter).
Wie realisiert man sowas? Als WebPart? Aber wohin muss ich den Wert (Begonnen, Nicht Begonnen) dann speichern?
Danke
Unfug
Hallo gfoidl,
hab ich mir fast schon gedacht.
Man hat also nur noch die Möglichkeit eine *.exe mit den entsprechenden Funktionen auszustatten und dann diese über das Hauptprogramm zu starten.
ProcessStartInfo startInfo = new ProcessStartInfo();
startInfo.UseShellExecute = true;
startInfo.WorkingDirectory = Environment.CurrentDirectory;
startInfo.FileName = @"C:\...\MeineExe.exe";
startInfo.Verb = "runas";
startInfo.Arguments = string.Empty;
Process p = Process.Start(startInfo);
Oder das Hauptprogramm direkt mit Adminpriviliegen starten. (ManifestDatei)
Gruß
Hallo,
ich häng mich mal an den Thread an, da ich ein ähnliches Problem habe.
Selbes Verzeichnis, selbe Geschichte.
Ist es nicht theoretisch möglich die schreibenden Methoden auszulagern in eine Assembly (*.dll) und dann im Hauptprogramm die Assembly mit Adminrechten zu starten?
Im Grunde so:
Assembly ass = Assembly.LoadFrom("ausgelagert.dll");
ass.CreateInstance("ausgelagert.NamederKlasseMitKonstruktor");
Nur müsste man beim Aufruf irgendwie mitgeben, dass man Adminrechte benötigt. Geht das?