Laden...

Forenbeiträge von codesoldier Ingesamt 26 Beiträge

03.09.2019 - 17:39 Uhr

Vielleicht hilft Dir Fiddler hier weiter?
https://www.telerik.com/fiddler

Da siehst Du dann auch die Antwortzeiten, die Größe des Requests / Response usw.

02.09.2019 - 14:55 Uhr

@CrocodileDundee:

Mit PostMan kann Du Dir den C#-Code generieren lassen.
Dazu einfach den Code-Button betätigen und dann C# auswählen:
https://learning.getpostman.com/docs/postman/sending_api_requests/generate_code_snippets/

Einzige Voraussetzung ist dass Du RestSharp verwendest:
http://restsharp.org/

22.08.2019 - 15:53 Uhr

@TheLion092:

Ich würde dir MVVM Light empfehlen.
Das macht das Erstellen von MVVM-Applikationen wesentlich leichter, da Du Dir z.B. das hantieren mit INotifyPropertyChanged ersparst.

15.08.2019 - 12:18 Uhr

Das ist ein uraltes Problem.
Normalerweis würde man die Constraints temporär droppen und dann eine neue Identity-Spalte hinzufügen und die alte löschen.

Wenn Dir das zu aufwendig ist, gibt es ein paar Tricks die hier beschrieben werden:

https://stackoverflow.com/questions/6084572/sql-server-how-to-set-auto-increment-after-creating-a-table-without-data-loss/6086661#6086661

13.08.2019 - 18:07 Uhr

Hi panicJonny,

an NuGet führt mMn kein Weg vorbei.

Ich vermeide klassische .NET Framework-Projekte, denn die benötigen (wie Du geschrieben hast) manuelle Zuarbeit.
Meine Bibliotheken sind nur noch .NET-Standard-Projekte, bei denen ich das Target-Framework in der Projektdatei anpasse, um Legacy-DLL's und gleichzeitig .NET-Core DLL's zu erzeugen.
Das sieht ungefähr so aus:


<TargetFrameworks>net46;netstandard2.0</TargetFrameworks>

Damit bekommst Du das Packaging-Feature von Visual Studio geschenkt 😃

Bei reinen Legacy-Projekten, habe ich leider auch noch keinen anderen Weg gefunden, als die .nuspec-Datei selber zu erzeugen und dann über nuget.exe das Paket bei Bedarf zu erstellen:


nuget.exe pack -IncludeReferencedProjects -properties Configuration=Release

Ein Repository-Verzeichnis würde ich nicht verwenden.
Ich benutze einen Nexus-Server, der ist kostenlos und einfach zu installieren:
https://de.sonatype.com/nexus-repository-sonatype

Das Ganze könnte man/frau automatisieren (z.B. per nuget push) und auch die Versionierung ist wohl automatisch machbar:
https://stackoverflow.com/questions/23754398/how-do-i-auto-increment-the-package-version-number

Da kann man sich mit Batch-Dateien, PowerShell usw. austoben, aber ich würde das ehrlich gesagt nicht machen. Der Weg über .NET-Standard-Projekte zu gehen ist leichter und zeitgemäßer.

Bezüglich SVN kann ich Dir nur den Tip geben: Wechsel zu Git.
Es ist wirklich ein Quantensprung bezüglich der Versionierung und der Teamarbeit.
Ein eigener GitLab-Server auf ner kleinen Ubuntu-Kiste ist schnell aufgesetzt oder Du verwendest eine AWS-Maschine:
https://aws.amazon.com/marketplace/pp/B071RFCJZK

25.07.2019 - 15:58 Uhr

Du kannst MSBuild 15 & 16 parallel installieren.
In meinem Jenkins habe beide Versionen hinterlegt und kann dann für ältere Projekte den 15er nehmen.
Für .NET Core Projekte verwende ich den 16er MSBuild.

25.07.2019 - 14:22 Uhr

Ich verwende MVVM-Light in meinen XAML/UWP-Anwendungen und hier gibt es einen Messenger, der genau solche Szenarien abdeckt.

https://stackoverflow.com/questions/18087906/use-mvvm-lights-messenger-to-pass-values-between-view-model

In PRISM gibt es einen EventAggregator:
https://stackoverflow.com/questions/39708411/wpf-mvvm-light-messenger-and-prism-eventaggregator

Auch Caliburn hat so einen Messenger/EventAggregator.
Musst einfach mal schauen was Dein MVVM-Toolkit Dir da anbietet.

09.07.2019 - 15:39 Uhr

Technisch kannst Du das in C# mit Array.Resize() machen:

https://docs.microsoft.com/de-de/dotnet/api/system.array.resize?view=netframework-4.8

Hier findest Du eine Diskussion zu dem Thema:
https://stackoverflow.com/questions/327916/redim-preserve-in-c

Du solltest Deine Vorgehensweise vielleicht nochmal überdenken, Arrays sind schon sehr old-school und wenig flexibel.

06.08.2018 - 15:08 Uhr

@T-Virus:
Ich erwarte gar nichts - es sind Empfehlungen, mehr nicht.
Ob diese Empfehlungen das Thema Webentwicklung für brave_snoopy komplexer machen, sollte er entscheiden.

@Abt:
Mit der Antwort hast Du Dich in meiner persönlichen Wertschätzung absolut disqualifiziert.
Das ist ein Forum, in dem Leute um Hilfe fragen. Wenn Du anderen Entwicklern nicht helfen willst, dann antworte einfach nicht.

Die Zeit, die Du bis jetzt investiert hast, um brave_snoopy, zu "erziehen", hättest Du auch sinnvoll nutzen können, um ihm ein paar Empfehlungen aus Deinem Technologie-Stack zu geben.

Und mir zu drohen ist einfach nur billig, da hätte ich mehr von Dir erwartet.

06.08.2018 - 13:57 Uhr

Das sehe ich anders - aber Deine Meinung ist mir auch ziemlich egal 👅

06.08.2018 - 13:28 Uhr

Ja, der Umgangston ist hier manchmal rau 🤔

Verwende einfach ASP.NET Core MVC für das Backend.

Für den Datenlayer nimmst Du am Besten einen Micro-ORM wie Dapper.

Hier findest Du von dem Kollegen Abt ein schönes Beispiel für Dapper:
Welche (neuen) Zugriffstechnologien für SQL-Server / Firebird und C#? QLink & Co. verwenden?

ReactJS + Bootstrap für das Frontend.

ReactJS deswegen weil es die meiste Verbreitung hat und einfach zu lernen ist.

Beispiele und Libraries zu ASP.NET Core und React gibt zu genüge im Internet z.B.
Getting Started on ASP.NET Core

Das sollte erstmal locker für einen Monat Beschäftigung reichen 😉

27.07.2018 - 16:09 Uhr

Einfach und "schmutzig" aber funktioniert immer:
Mappe das Remote-Laufwerk als lokales Laufwerk.
Das kannst Du z.B. mit NET USE machen:


NET USE \\computername\sharename password /USER:[domainname\]username
xcopy, robocopy was auch immer ...
NET USE \\computername\sharename /DELETE

17.07.2018 - 15:32 Uhr

Schau Dir mal Sitefinity an.
Ist von Telerik. Es ist nicht billig, aber dafür ein Feature-Monster (Workflows, Marketing-Tools etc.) und der Support von denen ist ziemlich gut. Clientseitig kannst Du Dich da mit React, Vue, Angular etc. voll ausleben.

Soll es ein CMS auf Basis von ASP.NET Core sein könnte Orchard oder Piranha in Frage kommen - ich kenne beide aber nicht.

06.12.2017 - 16:41 Uhr

Hi Gimmick,

ich würde nicht direkt mit Reflection arbeiten - das ist zu langsam.
Es gibt genügend Libraries, die genau für Deinen Anwendungsfall entwickelt worden sind:

https://github.com/mgravell/fast-member

https://github.com/buunguyen/fasterflect

02.10.2017 - 13:14 Uhr

Du könntest mit Late-Binding arbeiten. Damit entfällt das direkte Referenzieren der Assembly 😉

Hier ist ein kleines Code-Snippet:



      public static void SendMail(string subject, string body, List<string> recipients)
      {
          const int olMailItemType = 0;
          const int olMailHtmlBodyType = 2;

          dynamic oApp = null;
          dynamic oNameSpace = null;
          dynamic oMail = null;
          dynamic oRecips = null;
          dynamic oRecip = null;

          try
          {
              // get a new instance of Outlook
              Type objClassType = Type.GetTypeFromProgID("Outlook.Application");
              oApp = Activator.CreateInstance(objClassType);
              oNameSpace = oApp.GetNamespace("MAPI");
              if (oNameSpace != null)
              {
                  oNameSpace.Logon();
              }

              // create a new mail item
              oMail = oApp.CreateItem(olMailItemType);

              if (oMail != null)
              {
                  // set the mail properties
                  oMail.BodyFormat = olMailHtmlBodyType;
                  oMail.HTMLBody = body;
                  oMail.Subject = subject;


                  // add the recipients
                  if (recipients != null && recipients.Count > 0)
                  {
                      oRecips = oMail.Recipients;

                      if (oRecips != null)
                      {
                          foreach (string recAddress in recipients)
                          {
                              oRecip = oRecips.Add(recAddress);
                              if (oRecip != null)
                              {
                                  oRecip.Resolve();
                              }
                          }
                      }
                  }

                  // display the new message
                  oMail.Display();
              }
          }
          finally
          {
              if (null != oRecip)
              {
                  Marshal.ReleaseComObject(oRecip);
              }

              if (null != oRecips)
              {
                  Marshal.ReleaseComObject(oRecips);
              }

              if (null != oMail)
              {
                  Marshal.ReleaseComObject(oMail);
              }

              if (null != oNameSpace)
              {
                  Marshal.ReleaseComObject(oNameSpace);
              }

              if (null != oApp)
              {
                  Marshal.ReleaseComObject(oApp);
              }
          }
      }


08.06.2017 - 13:21 Uhr

Es sei mal dahingestellt, ob es Sinn macht noch mit FoxPro zu arbeiten. 🤔
Vielleicht solltest Du über eine Datenmigration nachdenken?

Es gibt wohl einen EF-Provider:
https://github.com/tombrothers/VfpEntityFrameworkProvider2
Wenn EF also ein Must-Have ist, wäre das ein Versuch wert.

Ansonsten könnte man noch kommerzielle Produkte wie DevArt DotConnect & Entity-Developer evaluieren.

Ich würde Dapper den Vorzug geben, da dies mit jedem ADO.NET-Provider funktioniert:

Dapper has no DB specific implementation details, it works across all .NET ADO providers including SQLite, SQL CE, Firebird, Oracle, MySQL, PostgreSQL and SQL Server.

Dapper ist sehr einfach zu implementieren und wesentlich schneller als EF.

31.05.2017 - 16:26 Uhr

Ich wollte vom Thread-Ersteller eigentlich nur wissen, was für Karten er von Europa hat🤔

Fertig gerenderte Karten zum Download gibt es defacto nicht - die wären auch viel zu groß.

Der Hinweis, dass ein rendern nur notwendig ist, wenn man eine eigene Darstellung benötigt, stimmt so auch nicht.

Schau Dir mal die Tile Usage Policy von OpenStreetMap an:

OpenStreetMap data is free for everyone to use. Our tile servers are not.

Mein Kunde hatte sich genau deswegen für einen eigenen OSM-Server entschieden, weil OpenStreetMap bei mehr als 2 Client-Anfragen den Zugriff blockiert hat. Die Alternative wäre ein kommerzieller Anbieter wie MapQuest gewesen.

31.05.2017 - 13:41 Uhr

Klar gibt es
>
. Selber rendern mußt du nur, wenn du eine eigene Darstellung benötigst.

Poste mal bitte den Download-Link für fertig gerenderte Karten von OSM.
Vorzugsweise die ganze Welt in allen Zoomstufen 😉

31.05.2017 - 10:42 Uhr

Was für Karten von Europa hast Du denn?
OpenStreetMap-Karten sind nicht vorgerendert, sondern Polygone.

Für das Rendering musst Du einen eigenen OSM-Server aufsetzen.
Normalerweise nimmst Du dafür ein Linux-Derivat, PostgreSQL/PostGis, Apache, Mapnik, renderd & CartoCSS.

Ich habe das letztes Jahr mal aufgesetzt für einen Kunden, das hat ca. 2-3 Tage gedauert, bis der Server lief. Das Importieren der Kartendaten hat nochmal einen Tag gekostet.

Die Performance war dann eher durchwachsen, weil das Rendering den Server stark beansprucht, gerade wenn mehrere Personen gleichzeitig drauf arbeiteten wurden die Kacheln in Zeitlupe gerendert.
Ich habe deswegen die Karten mit render_list vorgerendert - das hat ca. 1 Woche gedauert, bis die meisten Zoomstufen gerendert waren ...

Aus eigener Erfahrung, würde ich Dir deswegen eher davon abraten.
Der Aufwand so einen Server zu betreiben und die Karten aktuell zu halten ist schon sehr hoch.

24.03.2017 - 12:30 Uhr

Hi Emuuu,

da Du einen SQL-Server verwendest, würde ich Dir die SQL-Server Reporting Services empfehlen.
Du gestaltest die Reportdatei nach Deiner Excel-Vorlage und kannst, wenn der Prozess immer noch zu lange dauert, die Berichtsgenerierung schedulen z.B. immer nachts anstossen.

21.03.2017 - 16:37 Uhr

Hi Ramokhtan,

nur mal als spontane Idee:
Vielleicht hilft dir die Chromium-Engine weiter?
Die kannst du über CefSharp in Deine Anwendung einbetten und das alte WebBrowser-Control ersetzen:

http://ourcodeworld.com/articles/read/173/how-to-use-cefsharp-chromium-embedded-framework-csharp-in-a-winforms-application

https://github.com/cefsharp/CefSharp

Ist vielleicht mal einen Versuch wert =)

15.03.2017 - 15:46 Uhr

Schau Dir mal Metro UI an.
Insbesondere die Templates könnten für Dich interessant sein.

15.03.2017 - 10:44 Uhr

Hallo Dominik,

du baust gerade einen "Wrapper" für SQLite.
Die gibt es aber schon, schau Dir mal NPoco oder Dapper an.

Damit kannst Du dann die von Rufo erwähnte Person-Klasse mit Daten füllen.

29.11.2016 - 10:46 Uhr

Schau Dir mal Syncfusion an. Nicht so gut wie DevExpress oder Infragistics, aber dafür gibt es eine kostenlose Community-Edition:

https://www.syncfusion.com/products/windows-forms/grid-control

29.11.2016 - 10:39 Uhr

Bei Windows CE wird Dir nichts anderes übrig bleiben als das.NET Compact-Framework oder C++ zu verwenden. Die Geräte und das Betriebssystem sind so alt, dass ich mir nicht vorstellen kann dass Xamarin oder NativeScript darauf laufen.

Eine Webanwendung wäre natürlich auch denkbar, aber ob der veraltete Browser darauf jQuery, geschweige denn Bootstrap unterstützt wage ich zu bezweifeln, da wird Dir nicht viel mehr als HTML 4 übrig bleiben.

Mein Vorschlag wäre ein einfaches UI-Frontend, indem nur die Daten abgesendet werden. Die Logik lagerst Du dann in einem Webservice aus.

09.11.2016 - 13:55 Uhr

Hi,

vielleicht hilft Dir StormLib weiter? Damit kannst Du Deine eigenen MPQ-Dateien erstellen und lesen:
StormLib

Es gibt auch einen C#-Wrapper auf GitHub.