Dann wäre es aber höchst unwahrscheinlich, dass das Update/Insert mit einem

Fehlermeldung:
The multi-part identifier "Pers.-Nr" could not be bound.

knallt.

Du könntest Dir z.B. den Abschnitt in http://openbook.rheinwerk-verlag.de/visual_csharp_2012/1997_18_001.html#dodtp34972f67-6c1a-406f-a91d-ec8ff67058f9 ansehen.

Ansonsten ist eine Möglichkeit eben genau das was Bernd geschrieben hat. Das muss keine Datenbank sein.

Genauso könnte dort nur eine Textfile liege, welche die aktuell gültige Versionsnummer enthält. Deine Applikation kann dann nur gestartet werden, wenn diese mit der der Anwendung übereinstimmt. Dann würdest Du eben keine weiteren Starts zulassen. Irgendwann sind dann deine Dateien vielleicht nicht mehr im Zugriff.

Oder aber du erzeugst eine Ordnerstruktur in dem die Versionen liegen. Der Aufruf erfolgt über ein Shortcut, welches Du anpasst, wenn es eine neue Version gibt.

Dennoch schließe ich mich hier FZelle und Abt an, dass das direkte Ausführen von Software auf dem Netzlaufwerk ein No-Go ist.

Hast Du nun das Problem, dass du Dateien nicht austauschen kannst, weil diese gerade in Verwendung sind oder dass Du nicht weißt, wer welche Version installiert hat?

Naja, dass musst Du ja irgendwann in deinem DataSet angegeben habe. Du kannst dort den entsprechenden Adapater auswählen und siehst in den Eigenschaften die unterschiedlichen Statements.

Das die Authorisierung nicht im DAL passiert sollte selbstverständlich sein. Ich hoffe, dass dies nicht so zwischen den Zeilen/Posts steht 😃.

Aber sprechen wir hier nicht dann dennoch wieder von z.B. einem "SimpleProduct" und von mir aus einem zusätzlichen "FullProduct" Endpoint?

Wobei SimpleProduct für die beschriebene 3rd Party und FullProduct eben für z.B. die Hauptanwendung freigegeben wird?
Das würde mich dann aber wieder zum Eingangspost zurückführen... Da dies letzten endes für das DAL nur ein partial Update der Gesamtentität ist!?

Ja, ggf. wäre auch SDK ein passender Ausdruck. Die Bereitstellung wird jedoch sehr wahrscheinlich via Web (Intranet) geschehen.

Wie gesagt möchte ich zumindest den DAL ggf. auch zukünftig als einfache Library für die Hauptapplikation nutzen (oder auch komplett über die "öffentliche" API/SDK).

Was ich wie gesagt **vermeiden **möchte ist, dass 3rd-Party Nutzer Daten ändern kann, die nicht dafür vorgesehen sind. Diese Gefahr sehe ich eben, wenn ich diesen immer den vollständigen Datensatz zur gebe.

Falls es irgendwie einen Unterscheid machen sollte... ich spreche hier nur von firmeninternen Applikationen die darauf zugreifen.

Kannst Du uns das Statement zeigen?

Bitte verwende die Code-Tags.

Multi-Part bedeutet in dem Zusammenhang, dass dein Updatestatement mehrere Tabellen beinhaltet und in mehreren Tabellen die Spalte "Pers.-Nr" vorkommt. Du musst diese im Statement also vollständig angeben z.B. Tabelle1.[Pers.-Nr].

Aber die Controls zeigst Du ja nicht zum gleichen Zeitpunkt an. Es ist also kein Problem dies so zu tun. Auch die Größe deiner .exe ist erstmal völlig egal.

Ich lasse mich gerne überzeugen, bin es aber noch nicht 😃.
Ich kann auch nicht bestätigen, dass der DAL die DTO kennt bzw. damit arbeitet. Das Repository kennt nur Product. Das Übertragen der Eigenschaften von der DTO auf das DAL-Model übernimmt an der Stelle ja der FooService.

Das ganze Objekt heisst i.d.R. ohne Navigation-Properties bzw. diese wenn dann explizit.

Folglich führt eine unbedachte Nutzung also immer zu einem "SELECT * FROM x"? Das verursacht irgendwie Bauchschmerzen, wenn ich doch weiß, dass der Rest des Models den Benutzer gar nicht interessiert. Oder versteh ich hier etwas falsch?

Hmmm, ich bin nicht an eine REST API gebunden. Und in wiefern widerspräche ein DTO, welche ja vollständig geliefert werden würde, dem Grundsatz, dass das ganze Objekt geliefert wird?

Das ganze Objekt kann ja nicht immer den vollen Datenstand aus der Datenbank bedeuten!?

Darüber, dies mit Vererbung zu erschlagen, habe ich tatsächlich noch nicht nachgedacht. Allerdings sollten in diesem Moment ja auch Inserts für die "Partial"-Entity verboten werden. Wobei dies ja auch kein gewünschtes/benötigtes Verhalten ist.

Es geht mir z.B. darum, dass der API Konsument auch nur die Felder ändern kann, die an der entsprechenden Stelle vorgesehen sind. Da klang es für mich plausibel, diesem auch nur diese Felder anzubieten.

Ein eigenes PartialModel würde welche Auswirkungen habe?:

• eigenes Repository (ohne Insert, ggf. ohne Delete)
• im Fall von z.B. Dapper zusätzliche Selects sofern man es nicht bei "SELECT * FROM <tableName>" belässt

Ich führe mal anhand eines Beispiels aus, was genau ich mit partial meine.
Im Beispiel wird SQLite, Mapster und Dapper genutzt.

Folgendes Repository sei gegeben:

public class ProductRepository : IRepository<Product>
    {
        private IDbConnection _connection;

        public ProductRepository(IDbConnection connection)
        {
            _connection = connection;
        }

        public Product Get(int id)
        {
            return _connection.Query<Product>("SELECT Id, Name, Description, IsActive, CreateDate, VendorId FROM Product WHERE Id = @id", new { id = id }).SingleOrDefault();
        }

        public bool Update(Product entity)
        {
            return _connection.Execute("UPDATE Product SET Name = @Name, Description = @Description, IsActive = @IsActive, VendorId = @VendorId WHERE Id = @Id", entity) > 0;
        }
}

Die Klasse Product besitzt natürlich entsprechend alle nötigen Properties.

Dazu gibt es den FooService.

    public class FooService
    {
        IRepository<Product> _productRepository;

        public FooService(IRepository<Product> productRepository)
        {
            _productRepository = productRepository;
        }

        public Product GetFull(int productId)
        {
            var fullItem = _productRepository.Get(productId);
            return fullItem;
        }

        public DTO.ProductUpdateActive GetActiveProduct(int productId)
        {
            // Vollständiges Item abrufen, nicht ganz so schön, da natürlich unnötig viel abgefragt wird...
            var fullItem = _productRepository.Get(productId);
            // Mappen des Products auf ProductUpdateActive (enthält nur Id, Name und IsActive)
            var partialItem = TypeAdapter.Adapt<DTO.ProductUpdateActive>(fullItem);

            return partialItem;
        }

        public bool UpdateActiveProduct(DTO.ProductUpdateActive item)
        {
            // Vollständiges Item abrufen, nicht ganz so schön, da natürlich unnötig viel abgefragt wird...
            var fullItem = _productRepository.Get(item.Id);
            // Mappen der Properties von ProductUpdateActive (enthält nur Id, Name und IsActive) zurück ins volle Item
            var updatedFullItem = TypeAdapter.Adapt<DTO.ProductUpdateActive, Product>(item, fullItem);

            return _productRepository.Update(updatedFullItem);
        }
    }

Und so würde z.B. eine Verwendung aussehen.

 class Program
    {
        static Container container;

        static void Main(string[] args)
        {
            // Init Container
            Config();
            var foo = container.GetInstance<FooService>();

            var full = foo.GetFull(2);
            Console.WriteLine(string.Format("Full ### Id: {0}, Name: {1}, IsActive: {2}", full.Id, full.Name, full.IsActive));

            var partial = foo.GetActiveProduct(2);
            Console.WriteLine(string.Format("Partial ### Id: {0}, Name: {1}, IsActive: {2}", partial.Id, partial.Name, partial.IsActive));
            partial.IsActive = !partial.IsActive;
            Console.WriteLine(string.Format("Partial ### Id: {0}, Name: {1}, IsActive: {2}", partial.Id, partial.Name, partial.IsActive));

            var success = foo.UpdateActiveProduct(partial);
            full = foo.GetFull(2);
            Console.WriteLine(string.Format("Full ### Id: {0}, Name: {1}, IsActive: {2}", full.Id, full.Name, full.IsActive));
        }
...
}

Schöner fände ich natürlich, wenn tatsächlich nur die Felder geupdated werden, die auch im ProductUpdateActive vorhanden sind und genauso auch nur diese abgefragt werden.

Das EF könnte an dieser Stelle dies ja durch das ChangeTracking entsprechend erledigen und nur IsActive updaten.

Im Anhang das volle Beispielprojekt.

Das Dapper nur ein MicroORM ist, ist mir wohl bewusst, aber es geht mir ja auch nicht (direkt) um den Featureumfang etc.

Inwiefern kann mir FluentMigrator weiterhelfen? Ich möchte ja nicht die aktuelle Datenbank ändern oder sonstiges.

verwendetes Datenbanksystem: MSSQL

Hallo zusammen,

ich stelle aktuell mal wieder eine API für den Zugriff auf eine Applikation/Datenbank zur Verfügung. In der Hauptapplikation selbst gibt es leider kein entsprechendes DAL, welches ich dafür verwenden möchte. Die benötigte API muss dabei allerdings aktuell nur einen geringen Umfang des Gesamtsystems abdecken. Als Seiteneffekt möchte ich jedoch langfristig das aktuelle DAL durch diese API/DAL ersetzen.
Zuletzt habe ich für einen ähnlichen Task das EF (6.x) genutzt und war damit auch recht zufrieden, wobei mir aber gerade das Verhalten im disconnected Bereich dort doch immer mal wieder Schwierigkeiten bereitet hat.

Aktuell mache ich mir Gedanken wie partielle Updates sauber und dennoch bequem abgebildet werden können. Gefunden habe ich dazu hauptsächlich die Herangehensweise, dass an den entsprechenden Properties der State geändert wird. (z.B. http://stackoverflow.com/questions/12871892/entity-framework-validation-with-partial-updates )
Alternativ sieht für mich flexibler und sauberer aus mit entsprechenden DTOs zu arbeiten und diese einfach zu mappen.

Wie führt ihr im Normalfall partielle Updates durch?

Ich wollte mir in diesem Zusammenhang ggf. auch Alternativen wie z.B. Dapper näher ansehen. Soweit ich dies dort sehe, wäre es hier nun wieder notwendig entsprechende Updates zu schreiben oder natürlich passende Extensions ( z.B. http://www.bradoncode.com/blog/2012/12/creating-data-repository-using-dapper.html )

Für sonstige Anregungen bin ich natürlich auch offen 😃.

Funktioniert ein Typed Dataset überhaupt in Verbindung mit MS Access?

Auf z.B. Seite 17 wird aber z.B. entsprechend

~/ConsoleApp/ $ dnx ef migrations add MyFirstMigration

gezeigt.

-- Edit:
Bzw. entsprechend für ASP.NET 5 auf Seite 27.

Okay klar, ich bezog mich dabei auf Datenbanken wie z.B. SQLite.

Dir stehen dabei alle Möglichkeiten offen. Speichern in einer Datei, Datenbank etc.

Du musst nur entsprechend die Berechtigung durch den Nutzer dafür einholen. (Im Manifest)

Dein Aufruf

 ExcelApp.Workbooks.Open(curFile);

ändern in

ExcelWorkbook = ExcelApp.Workbooks.Open(curFile);

Warum orientierst Du dich nicht an z.B. Outlook?

Vorstellen könnte ich mir auch ein Grid mit sehr vielen Spalten und Du kümmerst dich einfach nur um das korrekte Setzen der Column und ColumnSpan Eigenschaft?

Oh, mein Fehler 😃. Du musst dem ExcelWorkbook auch dein geöffnetes Sheet zuweisen, ansonsten ist dies (vmtl.) null.

Du musst die Datei auch laden 😉

Wenn ich dich richtig verstehe, ist doch gar nicht die Anzeige dein Problem, sondern eben, dass ein ungültiger Wert eingegeben werden kann.

Hier wäre z.B. Maskierung (bzw. Masked Textbox) eine Möglichkeit.

Wobei es aber auch kein Hexenwerk ist einer lokalen Anwendung einen automatisches Update zu verpassen, sicherlich deutlich geringer im Vergleich zu einer Neuentwicklung in Technologie x.

Naja scheint als wäre der Installerdownload fehlerhaft. Probiers sonst mal mit der ISO statt dem Webinstaller.

Aber dann ist die Aufgabe doch klar definiert. Wenn Du dabei ein konkretes Problem hast und dieses nicht lautet "ich weiß nicht wie es geht...", dann kann dir auch weitergeholfen werden.

Ansonsten findest Du alles entweder in der MSDN z.B. https://msdn.microsoft.com/de-de/library/x9afc042.aspx oder in einem Buch deiner Wahl z.B. http://openbook.rheinwerk-verlag.de/visual_csharp_2012/

Deine Klasse kann z.B. ein Event haben "GeldGeaendert", welches Du entsprechend auslöst. Dieses abonnierst Du in Form1 und aktualisiert entsprechend dort deine Anzeige.

WCF + Rest gibt es ja. In dem Fall dann eben aber auch entsprechend über das webHttpBinding. Allerdings solltest Du wenn möglich eben wie bereits erwähnt ggf. nicht WCF wählen, wenn Du eine RESTful API haben möchtest. Dafür gibt es mittlerweile einfach bessere alternativen.

Aber dein Grundsätzliches Problem ist ja auch nicht REST sondern die Verbindung zum Endpoint.
Wie ist der Service denn gehostet? IIS? Self?

Dein Endpoint muss ja auch immer einfach per Browser erreichbar sein (zumindestens beim httpBinding 😃).

JSON kopieren und dann Bearbeiten => Inhalte einfügen => JSON als Klassen einfügen

Danke! Bei mir allerdings nur sichtbar, wenn der Texteditor den Fokus hat.

Hast Du es via ZipArchive.CreateEntry versucht? Dort musst Du dich eben um das blockweise Schreiben selbst kümmern.

(Was ich noch nur ungern zugebe: )
Ausserdem könnte ich tatsächlich kein DI umsetzen. Ich weiß zwar im groben, was das ist, aber alle meine Versuche einer praktischen Test-Umsetzung führten zu mehr Uständlichkeit statt zu weniger.
Wäre jetzt ein neuer Anlauf, wenn mir hier jetzt was praktikables präsentiert würde.

Das wäre doch noch was für die FAQ oder eher vielleicht als Artikel? 😃

Ich vermute mal, soweit ich dies nachvollziehen konnte, liegt der Hauptgrund warum man dies z.B. über einen Service nutzt in der Testbarkeit?

Hi,

wenn Du eine Nullexception bekommst, dann ist ganz sicher etwas Null 😃. Was genau kannst Du dir mit dem Debugger ansehen.
Ich würde die Funktionen nicht als Extension Methods bereitstellen. Wenn Du es gerne auf der Liste direkt haben möchtest, dann erb von List<> und implementier dort die Methoden.

Bei deinen ToString() solltest Du etwas wie z.B. string.Format() nutzen.

Hast Du dir die im Template angebotenen Authentifikationsmöglichkeiten angesehen? In dem Fall brauchst Du lediglich die Individual Accounts nutzen. Entsprechend gibt es dazu auch folgendes Beispiel:
http://www.asp.net/mvc/overview/security/create-an-aspnet-mvc-5-web-app-with-email-confirmation-and-password-reset

Öhm naja weil Du 2 Transaktionen hast. Jede diese Transaktion hat entsprechend Tipico als Buchmacher. Nun verknüpfst Du den Buchmacher mit den Wetten des Buchmachers.

Du hast also keine Verbindung zwischen Wetten und Transaktionen. Wozu also der JOIN? Entweder du hast eine Beziehung zwischen Transaktionen und zugehörigen Wetten oder der JOIN ist falsch.

Also Entweder SUMME der Transaktionen des Buchmachers + SUMME der Wetten des Buchmachers oder eben Transaktionen des Buchmachers + SUMME des Gewinns der Wetten der Transaktion.

Du solltest beim JOIN w und t matchen und nicht w und b.

Ich verstehe nicht, wieso es so schnell wie möglich für den Bearbeiter gehen soll und dieser dann doch auf die Verarbeitung der Fotos warten muss?

Wenn sowieso eine lokale Anwendung vorhanden ist... wieso bietet diese nicht eine saubere lokale Webschnittstelle, welche ohne den Umweg über eine Datei aufgerufen werden kann und einfach den entsprechenden Pfad zurückgibt?
Dadurch bist Du völlig unabhängig von irgendwelchen FileApi Implementierungen in den unterschiedlichen Browsern.

Du hast den Converter von dort übernommen? Sprich Namespace etc. passen?

Hi,

du nimmst die eingelesene Struktur und navigierst zur gewünschten Node. Dort gibt es dann entsprechend die Möglichkeit auch neue Elemente hinzuzufügen. (z.B. AddNode)

SQL? Welches?
Beim MSSQL Server kannst Du z.B. mit + arbeiten.

Allerdings ist das Abfragen der einzelnen Spalten + das Aufbereiten dieser Daten bevor du sie im Control anzeigst, die deutlich bessere Variante.

Grundsätzlich wäre eine Suche nach "concat string sql" bestimmt schneller gewesen.

Unter Downloads gibts die DLL. Unter Source Code den Code 😃.

Du kannst z.B. mit einer Func<Order,bool> in der where arbeiten.

Hi gfoidl,

streng ist so ein hartes Wort, aber ja es ist sofern möglich nach MVVM umgesetzt. Es gibt zwar ein paar Dinge nicht sauber abgebildet wurden, aber diese wäre hier wohl tatsächlich vernachlässigbar.

Ich werde mir PNunit mal näher ansehen, vielen Dank schonmal.

Beste Grüße

Hallo zusammen,

ich bin auf der Suche nach entsprechenden Werkzeugen um das Verhalten eines Mehrbenutzersystems bei gleichzeigitgem Zugriff zu simulieren/testen.
Es geht mir dabei also um eine "vollständige" Testabdeckung sondern es sollen dabei "normale Nutzungsszenarien" geprüft werden.

Das betroffene Tool ist dabei unterteilt in WPF Client + Serverkomponente mit WCF Services.
Vorstellen könnte ich mir an der Stelle direkt die WCF Services entprechend aufzurufen oder eben entsprechende UI Automation. Wobei letzteres meinem Empfinden nach verlässlichere Informationen liefern kann.

Ich habe mir das hier öfters erwähnt AutoIT angesehen, welches allerdings (sofern ich dies richtig verstanden und gesehen habe) WPF nicht unterstützt.
Genauso habe ich auch Coded UI Tests gesehen, allerdings bin steht mir dies aktuell mit der Professional Version nicht zur Verfügung.

Welche Empfehlungen könnt ihr für solche Anforderungen abgeben? Für meinen Fall könnte mir ein einfacher "Makrorecorder" vielleicht reichen.

Beste Grüße

Hmmmm, nutzt Du einen absoluten oder relativen Pfad? Falls relativ ist ggf. die WorkingDirectory in dem Fall inkorrekt?

Nun die Filterattribute geben doch jeweils das Ziel bereits vor und somit auch wie du mit dem Abfragewert vorgehen musst bzw. was als Eingabe erlaubt ist.

Wenn du nun eben prüfen möchtest, ob dein gewähltes Mitglied in den angegeben Gruppen ist bzw. 1+2 oder 3 was hindert dich daran?

Alle Geräte haben ja eine eigene Auflösung, wodurch sich ein Bild in gleicher Auflösung unterschiedlich darstellt.

Verrückt.... was sind denn die Fehler? Wie sieht dein Aufruf aus?

Wenn Du den nötigen Aufruf kennst, dann kannst Du doch ohne Probleme über den Debugger schauen, was tatsächlich ausgeführt wird und so die nötigen Anpassungen vornehmen.

Naja du musst eben deine Methode Send auf dem Server invoken.
Die Clients müssen entsprechend broadcastMessage abonnieren.

Dies ist jedoch super erklärt auf SignalR - Getting Started.
Für deinen SelfHosted Fall entsprechend weiterführend dann: Using SignalR in WinForms and WPF