Hi,

was hat denn in deinen Augen ein DataGridView mit einer Datenbank zu tun?

Ein DataGridView lässt sich an unterschiedlichste Listen binden - sogar gegen ein simples Array. Zugegeben - auch an DataTables und DataViews (welche sich übrigens ebenfalls ohne Datenbank verwenden lassen).

Der Tip ging nur um Folgendes: Du versuchst mit Textboxen und Buttons eine Lösung zu erstellen, die ein DataGridView bereits im Standard (und deutlich hübscher) beherrscht.

Als Beispiel (sollte ändern, löschen und hinzufügen bereits beherrschen, für das Hinzufügen solltest du ggf. aber separate Controls hinzufügen):

using System.Collections.ObjectModel;
using System.ComponentModel;
using System.Windows.Forms;

namespace WindowsFormsApp3
{
    public partial class Form1 : Form
    {
        public Form1()
        {
            InitializeComponent();

            var articles = new ObservableCollection<Article>(new []
            {
                new Article {Name = "Artikel 1", Price = 20},
                new Article {Name = "Artikel 2", Price = 30}
            });
            
            var dgv = new DataGridView
            {
                Dock = DockStyle.Fill,
                AutoGenerateColumns = false
            };

            dgv.Columns.Add(new DataGridViewTextBoxColumn {HeaderText = "Name", DataPropertyName = "Name"});
            dgv.Columns.Add(new DataGridViewTextBoxColumn {HeaderText = "Preis", DataPropertyName = "Price"});
            dgv.Columns.Add(new DataGridViewButtonColumn {Text = "Löschen", UseColumnTextForButtonValue = true});

            dgv.CellClick += (sender, args) =>
            {
                if (!(dgv.Columns[args.ColumnIndex] is DataGridViewButtonColumn) || args.RowIndex < 0) return;
                dgv.Rows.RemoveAt(args.RowIndex);
            };
            
            dgv.DataSource = new BindingList<Article>(articles);
            Controls.Add(dgv);

            articles[0].Name = "Test;";
            articles.Add(new Article {Name = "Test 2", Price = 10});
        }
    }

    public class Article
    {
        public string Name { get; set; }

        public decimal Price { get; set; }
    }
}

PS: Die BindingList unten bei der Zuweisung an die DataSource sorgt im Endeffekt dafür, dass DataGridView mittels BindingList mit der ObservableCollection kommuniziert.

PPS: Das DataGridView erweitert seine Fähigkeiten je nachdem welche Art von Liste gebunden wird - für simple Listen ist das lediglich Anzeige. Eine IBindingList (wie hier) kriegt Support für Änderungen an den Listen. Für eine Implementierung von IBindingListView (z.B. eine DataView) gibts von Haus aus Sortieren, Filtern & Co. geschenkt.

LG

Hi,

du hast tabellarische Daten - also solltest du auch eine richtige Tabelle verwenden.

Unter WindowsForms wäre das ein DataGridView - da würde ich an deiner Stelle mal 1-2 Tutorials anschauen und dann damit experimentieren.

LG

Hi,

also das Anliegen kann ich verstehen, sofern all diese Daten nicht wirklich erfasst sind. (Wobei es mich persönlich schon erschreckt, wie manche Firmen mit ihren Daten umgehen...)

Die Vorgehensweise finde ich persönlich nicht so toll - du nennst es vll flexibel - letztendlich ist es das aber nicht wirklich, weil du allen Leuten bei der Benamung Ihrer Artikel (stillschweigend und in meinen Augen ohne Kontrollmuster) vorschreibst, wie ein Artikel benannt werden muss. Mag in einem kleinen Kreis funktionieren - kann aber schon beim ersten neuen Mitarbeiter schief gehen.

Da würde ich (wenn du nicht gerade Lust hast alle Daten nachzufassen) eher hingehen und eine Tabelle von Gruppen, die jeweils ihr Parent kennen anlegen und anschließend in der eigentlichen Datentabelle dafür sorgen, dass diese entsprechend ihre Gruppe (vll auch sogar Gruppen? - dann über eine weitere Tabelle) kennen. Für den Start kannst du das sicher auf Basis des Strings automatisiert anlegen - danach würde ich es jedoch den Leuten überlassen bewusst zu bestimmen unter welche Gruppe/Gruppen das Teil gehört.

Im Sinne von:
Group
-Id
-Name
-ParentId<Nullable, für Root-Objekte>

Data
-Id
-Name
-GroupId

oder direkt für mehrere Gruppen:
Group
-Id
-Name
-ParentId<Nullable, für Root-Objekte>

Data
-Id
-Name

GroupData
-Id
-GroupId
-ParentId

LG

Hi,

naja - Abt gruppiert nach Wert, was dazu führt, dass alle Werte in einer Gruppe mit gleichen Werten zusammengefasst werden. So auch ist der Rückgabewert des Aufrufs vom Typ:

IEnumerable<IGrouping<string, KeyValuePair<int, string>>>

(Das ist der Part mit dem .GroupBy)

Wenn man dann nur die Gruppen betrachtet, die genau ein Element beinhalten - sind alle Werte mit Duplikaten ausgeschlossen. (das ist der Part mit dem .Where)

Um das ganze wieder zu einem Dictionary zu machen - hilft die Methode "ToDcitionary", dabei wird es erforderlich sein einen KeySelector und einen ElementSelector zu formulieren.

Das könnte z.B. so aussehen:

var toDictionary =  noDuplicates.ToDictionary(grouping => grouping.Single().Key, grouping => grouping.Key);

LG

Edit: Der Typ string im Dictionary ist hier nur der Einfachheit halber - bei dir ists dann ja UserQuery.Test

Hi,

dann würde ich an deiner Stelle auf XML-Serialisierung zurückgreifen.

Als hilfreiches Tool für die Namespaces & Co um deine C#-Klassen zu generieren empfehle ich: http://xmltocsharp.azurewebsites.net/

LG

Hi,

das sieht nach einem SOAP-Service aus 😕

Hast du einen Link auf die WSDL-Datei? Woher kommt das Dokument?

LG

Hi,

soweit mir bekannt ist unterstützt log4net bei derartiger Konfiguration Umgebungsvariablen.

Die Variable "%APPDATA%" - sollte dir somit das gewünschte Ergebnis bringen. Die Syntax dafür findest du sicher über Google.

LG

Hi,

ja - dafür braucht man ein Zertifikat - das gibt's allerdings z.B. via LetsEncrypt kostenlos.

LG

Hi,

den Sinn hinter einer solchen Verschlüsselung sehe ich persönlich nicht. Wenn du es clientseitig machst - liegen sowohl der Schlüssel als auch die Verschlüsselungsmethode auf dem Client vor, womit dieser Schritt im Prinzip für die Katz ist. Der Server sollte dafür lieber schlicht über ein Zertifikat verfügen und ausschließlich HTTPS anbieten.

Passwörter speichert man generell irreversibel mit einem Hash (inkl. Salt), der es nicht erlaubt das ehemalige Passwort zu rekonstruieren. (Wenn deine DB geknackt wird haben die User sonst nämlich schnell mal ein Problem...) Mir ist in den letzten Jahren nur eine Firma begegnet, bei der ich gemerkt habe, dass mein Passwort im Klartext gespeichert wurde - habe mich sofort an den Datenschutzbeauftragten gewendet und mich dort löschen lassen.

Für das Wiederherstellen eines Passworts verwendet man normalerweise die vom User hinterlegte Email für einen speziellen codegeschützten Link, mit dessen Hilfe man schlicht ein neues Passwort setzt.

LG

Hi,

ich bin zwar nicht sicher, was deinerseits gegen eine Datenbank spricht - aber für einen Webserver ist ASP.NET (bzw. aktueller ASP.NET Core) durchaus einsetzbar.

Zur Kommunikation mit anderen Clients gibt es unzählbar viele Herangehensweisen - aber ich denke wenn du ein wenig die Tutorials zu SignalR durchschaust - kriegst du das schon hin.

Hier mal ein Beispiel:
https://blogs.msdn.microsoft.com/webdev/2018/02/27/asp-net-core-2-1-0-preview1-getting-started-with-signalr/

LG

PS: Ohne Loginsystem (und damit i.d.R. irgendeine Art von Datenbank für die Persistenz) würde ich keinen ChatClient veröffentlichen... (Es gibt ja schließlich ausreichend kostenfrei Varianten)

Hi,

2 Sachen:

a) Um dir dort zu helfen müsstest du denke ich die relevanten Codestellen preisgeben
b) Viele Leute hier erstellen selbst Websites, die von Bots missbraucht werden, sofern du ernsthaft an Hilfe interessiert bist und nichts für den Betreiber unerwünschtes tust - kann ich dir nur empfehlen die Seite bzw. deren Nutzungsbedingungen zu posten - andernfalls wirst du oft obwohl man dir helfen könnte - keine Hilfe bekommen, da Programme wie deines das Potenzial haben den Betreiber massiv zu belasten und dessen Kosten in die Höhe zu treiben.

Selbst wenn du das tust sei allerdings Folgendes angemerkt: Websites die Funktionalität hinter einer Authentifizierung verstecken - tun dies oft bewusst und bieten (sofern gewünscht) eine Schnittstelle für Programme an, da das automatisierte Zugreifen auf eine grafische Homepage weder klug noch praktisch ist. (In anderen Worten: Es ist höchst unwahrscheinlich, dass der Betreiber einen Zugriff wie den deinen erlaubt)

LG

Hi,

kann zwar zu log4net nichts sagen - aber SeriLog kann ich auch nur empfehlen.

LG

Hi,

an Stelle der Fragezeichen gehören dort soweit ich mich erinnere '@' hin.

Abseits davon hast du hoffentlich auch im Debugger geprüft, dass im Wert kein NULL steht?

LG

PS: Unter ADO.NET ist der Unterschied zwischen Mssql und Mysql kaum spürbar.

Hi,

das Beispiel ist zwar für die Konsole - aber da siehst du schnell wie man's angehen kann:
https://codereview.stackexchange.com/questions/127515/first-c-program-snake-game

Überdies würde ich dir dringend empfehlen deinen Code komplett aufzuarbeiten.

Was dort steht verstehst du selbst in wenigen Wochen nicht mehr...

LG

Hi,

mir ist die Frage nicht ganz klar bzw. die Unterscheidung.

Aber von der Praxis: Ein normaler Build unter VS führt in der Tat nicht zur vollständigen Erstellung eines Projekts, sodass es deployed werden könnte. Dafür gibt es die Veröffentlichungsfunktion.

Sind da die Ergebnisse auch nicht vollständig bei dir?

Oder machst du auf dem eigentlichen Produktivsystem auch direkt den Build?

Überhaupt: Welche Art von .NETCore-Projekt versuchst du zu veröffentlichen? SelfContained? Portable?

LG

Hi,

deine Frage wirkt irgendwie komisch - kann sein, dass ich diese schlicht nicht verstehe - aber meinst du:

alleSQL[0].saver

?

LG

Hi,

verschwinden wird die Warnung nicht soweit ich es verstehe.

Im Prinzip steht ja selbst in der MSDN, dass ein generischer Typ keine statischen Member beinhalten soll(te) -> daher auch die Warnung.

Da die Möglichkeit Operatoren in Instanzmember zu verwandeln nicht besteht - blendest du die Warnung entweder aus oder lebst damit.

Begründung von Microsoft lautet ja, dass Bibliotheken so "leichter angenommen" werden...

LG

Hi,

die Frage ergibt für mich immer noch keinen Sinn - aber - um mich an deine beiden Codebeispiele zu halten:

Zu 1)

string sqlCommandString = "Select * FROM Zeiterfassung.dbo.Mitarbeiter";

Zu 2 (Beachte "@Vertriebskanal" - das verwendet eventuell übergebene Parameter)

string sqlCommandString = "SELECT" +
"	AI.ViewCluster," +
"	AI.Artikelnummer, A.Matchcode," +
"	AI.Kanal AS Vertriebskanal," +
"	ISNULL(AI.IsGrouped, 0) AS IsGrouped," +
"	MGGFK.Sku_Gruppe AS GrpSKU," +
"	CAST(AI.AngelegtAm AS DATE) AS AngelegtAm" +
"FROM Artikelstammdaten.dbo.ArtikelImport AS AI" +
"LEFT JOIN SL_MMETA.dbo.ART AS A" +
"ON AI.Artikelnummer = A.Artikelnummer" +
"LEFT JOIN Artikelstammdaten.dbo.MT_get_gruppiertXeinfach_from_Kanal(@Vertriebskanal) AS MGGFK" +
"ON AI.Artikelnummer = MGGFK.Sku_Einfach COLLATE Latin1_General_CI_AS" +
"WHERE Kanal @Vertriebskanal" +
"ORDER BY ViewCluster, IsGrouped, Artikelnummer";

Hinweis: Bei längeren Befehlen (ich war hier zu faul dafür) empfiehlt es sich eigentlich den StringBuilder zu verwenden im Sinne von:

StringBuilder sb = new StringBuilder();
sb.AppendLine("mytext1");
sb.AppendLine("mytext2");
sb.AppendLine("mytext3");

Wie man so etwas dann ausführt - kannst du z.B. auf folgender Seite nachlesen (übrigens beim verlinkten FAQ-Eintrag über Parameter auch verlinkt):
http://openbook.rheinwerk-verlag.de/visual_csharp/visual_csharp_26_003.htm#mjaed852f5e366e95ecd103ddabd86eec1

Kurzform für Mssql:

using (SqlConnection connection = new SqlConnection(ConnectionSting))
  {
    connection.Open();

    using (SqlCommand cmd = new SqlCommand(sqlCommandString, connection))
    {
      cmd.Parameters.AddWithValue("@Vertriebskanal", <DeinVertriebskanal>);
      return cmd.ExecuteNonQuery();
    }
}

LG

Hi,

als Beispiel - um zu verdeutlichen wie viele solche Fehler machen und was dabei rausgekommen ist:

https://codecurmudgeon.com/wp/sql-injection-hall-of-shame/

Um's zu verdeutlichen: Wer sowas wissentlich macht - provoziert geradezu einen Angriff. Sicher - dadurch dass es eine Eigenentwicklung ist, die am Ende wohl keinen juckt ist ein Angriff vll nicht ganz so wahrscheinlich - aber man riskiert diesen ohne jede Not. Dabei sind Parameter noch aus anderen Gründen absolut sinnvoll.

Was deine eigentliche Frage angeht: Hier scheint nach wie vor niemandem klar zu sein was genau du wissen möchtest... VB ist halt kein C# - aber das wundert ja auch dich nicht. Die Frage ist eher - was wolltest du uns mit den beiden VB-Fetzen sagen?

LG

Hi,

soweit ich sehe hat keiner reines SQL abgelehnt. Lediglich die Parameter wurden an's Herz gelegt - und das hat keine Performanceeinbußen - sondern ganz konkrete Vorteile.

LG

Hi,

sofern ich dich richtig verstehe - nein das ist nicht global. Solange du dir nicht wirklich Mühe gegeben hat wird unter normalen Umständen nur "IsAuthenticated" rauskommen, wenn deine Seite ein entsprechendes Cookie erstellt hat.

Wenn du es anders wolltest - müsstest du dir entsprechend Mühe geben. Falls dem so ist - empfehle ich IdentityServer 4.

LG

@Abt - nichts - ich sagte lediglich, dass mir LiteDb für kleine Sachen (Anwendungen) gefällt.
Und da Textdateien für Rezepte definitiv unter kleine Sachen fällt - habe ich entsprechend LiteDb empfohlen.

LG

Hi,

wenn simple Textdateien ausreichen könntest du eventuell auch http://www.litedb.org/ einsetzen. Gefällt mir für kleine Sachen sehr gut.

LG

Hi,

nun - wenn alle Daten aus einem DMS kommen - sind diese ja bereits in einer Datenbank, die sich ggf. mit Hilfe von SQL auswerten lässt. Selbst wenn dem nicht so ist - scheint der Export im CSV-Format sein, mit dem du in C# deutlich leichter (und schneller) zu Leibe rücken könntest... Beide Varianten würde ich in jedem Fall Excel vorziehen.

LG

Hi,

Würde mich hypersurf anschließen.

Zum einen lässt sich sicher der VBA-Code optimieren - zum anderen dürften Formeln in der Tat genügen. Das ist für Endanwender in aller Regel komfortabler.

Abseits davon:
Mehr als 200.000 Einträge klingt in meinen Augen schon nach Missbrauch. Solche Datenmengen gehören eigentlich in eine ordentliche Datenbank...

LG

Hi,

falls dir DataBinding nicht gefällt - würde ich dir ehrlich gesagt WindowsForms an's Herz legen - das ist bei der (direkten) Manipulation von Steuerelementen deutlich intuitiver, da WPF-Anwendungen in den meisten Fällen mit Hilfe von MVVM aufgebaut werden.

Dass du hier keine wirklichen Tipps erhälst - sollte dich somit nicht länger wundern. Das liegt zum einen sicher daran, dass keiner Lust hat sich solchen Spaghetticode anzuschauen (was bei WPF selbst wenn man's ordentlich in der gezeigten Variante machen würde so ist) - zum anderen allerdings auch sicher daran, dass es hier noch keiner gemacht und entsprechend nicht weiß.

LG

Hi,

nach deinen Schilderungen ist davon auszugehen, dass die Daten zumindest ankommen.

Dementsprechend musst du nun die Einstellungen deines DataGridViews kontrollieren.

Zum einen gibt es einen Modus, in welchem automatisch Columns erstellt werden, zum anderen kann man das manuell machen und muss entsprechend die Bindungseinstellungen festlegen.

Was davon hast du wie getan?

LG

Hi,

wenn die Ordner direkt unter deinem Postfach sind - sind diese logischerweise keine Unterordner deines Posteingangs. (Was dein Code allerdings so erwartet - siehe WellknownFolderName.Inbox)

Ich weiß nicht mehr auswendig, welcher Eintrag von WellknownFolderName für das Postfach steht - bin aber sicher, du findest es raus 😉

LG

Hi,

nein - du machst nichts falsch. Das ist valides XML.

LG

@Abt
Was sagt dir, dass das nicht bereits geschieht?

Hi,

vielen Dank den Tipp - ich habe testweise den Dienst "Funktionssuche-Ressourcenveröffentlichung" wie im Link beschrieben gestartet. Leider hat auch dies nicht gefruchtet...

Was die Glaskugel angeht: Jup - es ist ein wenig schade, dass ich dazu absolut nichts finde.
Habe das mittlerweile auf einem 2. Client getestet - selbes Problem... Ich befürchte ich muss es dann langsam doch auf lokale Installationen schieben.

LG

Evtl betrifft Dich CredSSP-Updates für CVE-2018-0886

Hi,

das ist leider unwahrscheinlich, da sowohl der Client als auch der Server bereits weit vor dem Update des Clients auf 1803 entsprechende Updates erhalten haben, die eine Verbindung via RDP ggf. mit einem Fehler quittiert hätten. (was allerdings nicht der Fall ist)

LG

verwendetes Datenbanksystem: <EntityFramework 6, MSSQL 2016>

Hi,

ich habe seit neuestem ein Problem mit einem Mini-Programm.

Das Programm selbst wird mit Befehlszeilenargumenten (liegt auf einem UNC-Pfad im Netzwerk) gestartet - macht einige kurze Datenbankzugriffe und öffnet dann ein Outlook-Fenster.

Funkioniert problemlos unter Windows 7 bis Windows 10 Build 1709. Mit Update auf 1803 jedoch - löst dies ausnahmslos eine SqlException beim ersten Zugriff auf die Datenbank aus.

Als InnerException erhalte ich beim Debuggen eine Win32Exception:> Fehlermeldung:

• InnerException	{"Der Netzwerkpfad wurde nicht gefunden"}	System.Exception {System.ComponentModel.Win32Exception}
  

Das dumme an der Sache: Dieser Fehler tritt nur dann auf, wenn das Programm aus dem Netzwerk ausgeführt wird, was ich eigentlich gerne beibehalten möchte.

Da das Problem ja nur beim Client liegen kann - somit die eigentliche Frage:
Kennt jemand eine Einstellung um dies zu korrigieren oder hat alternativ einen Hinweis auf eine ggf. erfolgte Änderung?

Danke euch.

Falls relevant noch die Einträge im Windows-Eventlog:
SqlException:

Anwendung: SendMail.exe
Frameworkversion: v4.0.30319
Beschreibung: Der Prozess wurde aufgrund einer unbehandelten Ausnahme beendet.
Ausnahmeinformationen: System.ComponentModel.Win32Exception

Ausnahmeinformationen: System.Data.SqlClient.SqlException
bei System.Data.SqlClient.SqlInternalConnectionTds..ctor(System.Data.ProviderBase.DbConnectionPoolIdentity, System.Data.SqlClient.SqlConnectionString, System.Data.SqlClient.SqlCredential, System.Object, System.String, System.Security.SecureString, Boolean, System.Data.SqlClient.SqlConnectionString, System.Data.SqlClient.SessionData, System.Data.ProviderBase.DbConnectionPool, System.String, Boolean, System.Data.SqlClient.SqlAuthenticationProviderManager)
bei System.Data.SqlClient.SqlConnectionFactory.CreateConnection(System.Data.Common.DbConnectionOptions, System.Data.Common.DbConnectionPoolKey, System.Object, System.Data.ProviderBase.DbConnectionPool, System.Data.Common.DbConnection, System.Data.Common.DbConnectionOptions)
bei System.Data.ProviderBase.DbConnectionFactory.CreatePooledConnection(System.Data.ProviderBase.DbConnectionPool, System.Data.Common.DbConnection, System.Data.Common.DbConnectionOptions, System.Data.Common.DbConnectionPoolKey, System.Data.Common.DbConnectionOptions)
bei System.Data.ProviderBase.DbConnectionPool.CreateObject(System.Data.Common.DbConnection, System.Data.Common.DbConnectionOptions, System.Data.ProviderBase.DbConnectionInternal)
bei System.Data.ProviderBase.DbConnectionPool.UserCreateRequest(System.Data.Common.DbConnection, System.Data.Common.DbConnectionOptions, System.Data.ProviderBase.DbConnectionInternal)
bei System.Data.ProviderBase.DbConnectionPool.TryGetConnection(System.Data.Common.DbConnection, UInt32, Boolean, Boolean, System.Data.Common.DbConnectionOptions, System.Data.ProviderBase.DbConnectionInternal ByRef)
bei System.Data.ProviderBase.DbConnectionPool.TryGetConnection(System.Data.Common.DbConnection, System.Threading.Tasks.TaskCompletionSource1<System.Data.ProviderBase.DbConnectionInternal>, System.Data.Common.DbConnectionOptions, System.Data.ProviderBase.DbConnectionInternal ByRef) bei System.Data.ProviderBase.DbConnectionFactory.TryGetConnection(System.Data.Common.DbConnection, System.Threading.Tasks.TaskCompletionSource1<System.Data.ProviderBase.DbConnectionInternal>, System.Data.Common.DbConnectionOptions, System.Data.ProviderBase.DbConnectionInternal, System.Data.ProviderBase.DbConnectionInternal ByRef)
bei System.Data.ProviderBase.DbConnectionInternal.TryOpenConnectionInternal(System.Data.Common.DbConnection, System.Data.ProviderBase.DbConnectionFactory, System.Threading.Tasks.TaskCompletionSource1<System.Data.ProviderBase.DbConnectionInternal>, System.Data.Common.DbConnectionOptions) bei System.Data.ProviderBase.DbConnectionClosed.TryOpenConnection(System.Data.Common.DbConnection, System.Data.ProviderBase.DbConnectionFactory, System.Threading.Tasks.TaskCompletionSource1<System.Data.ProviderBase.DbConnectionInternal>, System.Data.Common.DbConnectionOptions)
bei System.Data.SqlClient.SqlConnection.TryOpenInner(System.Threading.Tasks.TaskCompletionSource1<System.Data.ProviderBase.DbConnectionInternal>) bei System.Data.SqlClient.SqlConnection.TryOpen(System.Threading.Tasks.TaskCompletionSource1<System.Data.ProviderBase.DbConnectionInternal>)
bei System.Data.SqlClient.SqlConnection.Open()
bei System.Data.Entity.Infrastructure.Interception.DbConnectionDispatcher.<Open>b__36(System.Data.Common.DbConnection, System.Data.Entity.Infrastructure.Interception.DbConnectionInterceptionContext)
bei System.Data.Entity.Infrastructure.Interception.InternalDispatcher1[[System.__Canon, mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089]].Dispatch[[System.__Canon, mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089],[System.__Canon, mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089]](System.__Canon, System.Action2<System.__Canon,System.__Canon>, System.__Canon, System.Action3<System.__Canon,System.__Canon,System.__Canon>, System.Action3<System.__Canon,System.__Canon,System.__Canon>)
bei System.Data.Entity.Infrastructure.Interception.DbConnectionDispatcher.Open(System.Data.Common.DbConnection, System.Data.Entity.Infrastructure.Interception.DbInterceptionContext)
bei System.Data.Entity.Core.EntityClient.EntityConnection.<Open>b__2()
bei System.Data.Entity.SqlServer.DefaultSqlExecutionStrategy+<>c__DisplayClass1.<Execute>b__0()
bei System.Data.Entity.SqlServer.DefaultSqlExecutionStrategy.Execute[System.__Canon, mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089]
bei System.Data.Entity.SqlServer.DefaultSqlExecutionStrategy.Execute(System.Action)
bei System.Data.Entity.Core.EntityClient.EntityConnection.Open()

Ausnahmeinformationen: System.Data.Entity.Core.EntityException
bei System.Data.Entity.Core.EntityClient.EntityConnection.Open()
bei System.Data.Entity.Core.Objects.ObjectContext.EnsureConnection(Boolean)
bei System.Data.Entity.Core.Objects.ObjectContext.ExecuteInTransaction[[System.__Canon, mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089]](System.Func1<System.__Canon>, System.Data.Entity.Infrastructure.IDbExecutionStrategy, Boolean, Boolean) bei System.Data.Entity.Core.Objects.ObjectQuery1+<>c__DisplayClass7[[System.__Canon, mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089]].<GetResults>b__5()
bei System.Data.Entity.SqlServer.DefaultSqlExecutionStrategy.Execute[System.__Canon, mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089]
bei System.Data.Entity.Core.Objects.ObjectQuery1[[System.__Canon, mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089]].GetResults(System.Nullable1<System.Data.Entity.Core.Objects.MergeOption>)
bei System.Data.Entity.Core.Objects.ObjectQuery1[[System.__Canon, mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089]].<System.Collections.Generic.IEnumerable<T>.GetEnumerator>b__0() bei System.Data.Entity.Internal.LazyEnumerator1[[System.__Canon, mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089]].MoveNext()
bei System.Linq.Enumerable.SingleOrDefault[System.__Canon, mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089]
bei System.Data.Entity.Core.Objects.ELinq.ObjectQueryProvider.<GetElementFunction>b__2[System.__Canon, mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089]
bei System.Data.Entity.Core.Objects.ELinq.ObjectQueryProvider.ExecuteSingle[[System.__Canon, mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089]](System.Collections.Generic.IEnumerable1<System.__Canon>, System.Linq.Expressions.Expression) bei System.Data.Entity.Core.Objects.ELinq.ObjectQueryProvider.System.Linq.IQueryProvider.Execute[[System.__Canon, mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089]](System.Linq.Expressions.Expression) bei System.Data.Entity.Internal.Linq.DbQueryProvider.Execute[[System.__Canon, mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089]](System.Linq.Expressions.Expression) bei System.Linq.Queryable.SingleOrDefault[[System.__Canon, mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089]](System.Linq.IQueryable1<System.__Canon>, System.Linq.Expressions.Expression1<System.Func2<System.__Canon,Boolean>>)
bei SendMail.Program.SendMail(Int32)
bei SendMail.Program.Main(System.String[])

ApplicationError:

Name der fehlerhaften Anwendung: SendMail.exe, Version: 1.0.0.0, Zeitstempel: 0x5b0555f6
Name des fehlerhaften Moduls: KERNELBASE.dll, Version: 10.0.17134.1, Zeitstempel: 0x149ab0fd
Ausnahmecode: 0xe0434352
Fehleroffset: 0x0010d722
ID des fehlerhaften Prozesses: 0x4198
Startzeit der fehlerhaften Anwendung: 0x01d3f74845c923f5
Pfad der fehlerhaften Anwendung: Y:\Moser.Extensions\SendMail\SendMail.exe
Pfad des fehlerhaften Moduls: C:\WINDOWS\System32\KERNELBASE.dll
Berichtskennung: 51216ee7-b930-4a0f-9931-e9520366765a
Vollständiger Name des fehlerhaften Pakets:
Anwendungs-ID, die relativ zum fehlerhaften Paket ist:

Hi,

deinem Beitrag entnehme ich, dass du eine Windows Forms Anwendung erstellt hast - XAML gehört allerdings (grundsätzlich) zu einer WPF-Anwendung. (Grundlegend verschiedene Technologien)

Ich musste selbst noch nicht WPF und Windows Forms miteinander vermischen - grundlegend ist es jedoch möglich, dass du eine WPF-ControlLibrary erstellst - dort das XAML in Form eines UserControls erstellst - das ganze kompilierst - und dann unter WindowsForms hostest. (Dazu findest du in der Toolbox den "ElementHost" - solltest du am besten einfach mal googeln.

LG

Hallo Petra,

leider wirst du um's Lesen nicht herum kommen.

Möchte dir des Weiteren noch folgenden Beitrag an's Herz legen:
[Hinweis] Wie poste ich richtig?

Wir geben hier i.d.R. Hilfe zur Selbsthilfe und machen nicht die Arbeit anderer. Die hast du.

LG

PS: Wenn sich jemand deinen Fehler anschauen soll - musst du zumindest die genaue Fehlermeldung dabei schreiben. Raten ist immer doof.

Hi,

eine FileNotFoundException würde nur ausgelöst werden, wenn du die Datei tatsächlich benutzen möchtest. Beim Lesen oder Schreiben.

Zum selbst prüfen hat MrSparkle bereits die korrekte Methode genannt.

LG

Hi,

ja - im einfachsten Fall macht es das ViewModel selbst.

-> ICommand initiiert die Löschung im ViewModel
-> ViewModel ruft Delete im Service oder Repository auf
-> Wenn das geklappt hat - entfernt das ViewModel den Eintrag

LG

Hi,

ICommand ist eigentlich nur für WPF üblich und so überhaupt möglich.

WindowsForms arbeitet mit Events.

LG

Hi,

vormachen wird es dir hier zwar keiner - aber Folgendes:
a) Dein Beispielcode berechnet nicht die Fakultät
b) Man kann den SourceCode von BigInteger im Internet finden, wenn man wissen möchte, wie man sowas angehen kann... siehe https://referencesource.microsoft.com/#System.Numerics/System/Numerics/BigInteger.cs

LG

Deine Implementierung eines BigIntegers ist natürlich reduzierter Aufwand, da diese lediglich die Zahlen speichern können muss und ausschließlich die Funktion der Multiplikation beherrschen muss. (siehe auch Methode "Mul" das BigIntegerBuilder)

Hi,

um dir den richtigen Suchbegriff zu geben: Du suchst ein Diff-Tool.

Recht vielversprechend sieht folgendes aus:
https://github.com/mmanela/diffplex

LG

Hi,

da ich ehrlich gesagt nicht denke, dass der TE einen Virus schreibt mal wenigst ein bisl Input:

Vom Grundsatz her versuchst du scheinbar ein neues Dateiformat zu basteln.

Mein Tipp: Lass es.

Du hast hier eine sehr simple Baumstruktur dargestellt, die sich problemlos mit JSON oder XML abbilden lassen könnte und dann auch mit Basisbibliotheken parsen lassen könnte. Es ergibt somit keinen Sinn das ganze noch mal zu bauen.

Falls es dennoch unbedingt erforderlich ist solltest du dir einfach mal andere Parser anschauen - z.B. JSON.NET:https://github.com/JamesNK/Newtonsoft.Json

LG

Hi,

das ist prinzipiell die rekursive Variante meines iterativen Vorschlags.

Kann man sicherlich so lassen - ich möchte an dieser Stelle allerdings anmerken, dass ähnlich wie bei der rekurisven Variante zum Auflisten von Verzeichnissen - auch bei deiner Vorgehensweise für's JSON zumindest die theoretische Möglichkeit eines StackOverflows besteht.

Wenn deine Methode sich selbst zu oft aufrufen muss - crasht somit potenziell das Programm. (Wenngleich hier wohl unwahrscheinlich)

Heisst: Falls es crasht - tut es das mit einer StackOverflowException.

LG

Auch zur Fehlermeldung:

Wie bereits gesagt: Du machst:

var myJson = JObject.Parse(string myJsonContent);
var myDictionary = ParseJsonToDictionary(myJson);

"myJsonContent" ist dabei natürlich der Inhalt der json-Datei.

Wie tief dein Json verschachtelt ist meiner Methode egal - hier wird iterativ über alles drübergerattert was in dem JObject (deine komplette JSON-Datei) drinsteht.

Der Fehler von dir ist kein Laufzeitfehler - sondern wird offenbar schon beim kompilieren geworfen. Das liegt am static-Modifizierer, den ich gewählt habe, weil ich nur in einer kurzen Konsolenanwendung programmiert habe.

Ab davon: Auch beim kopieren von Code solltest du das Kopierte anschauen und verstehen, sowie ggf. anpassen. Beim Anpassen hast du dann zwei Möglichkeiten:
a) Du entfernst das das static
b) Du gibst beim Aufruf der Methode den Namen der Klasse mit, in der die Methode ist - also "MyClass.ParseJsonToDictionary"

LG

Hi,

du machst dir das mit dem Transformieren in ein Dictionary viel zu schwer - hier mal als Ansatz (habs an deinem Beispiel getestet - Duplikate finden ist dann in 6 Zeilen ordentlich passiert):

private static Dictionary<string, string> ParseJsonToDictionary(JToken json)
        {
            var tokens = new Stack<JToken>();
            var values = new Dictionary<string, string>();

            tokens.Push(json);
            while (tokens.Count > 0)
            {
                var current = tokens.Pop();

                if (current.HasValues) // has children?
                {
                    foreach (var value in current.Values())
                    {
                        tokens.Push(value);
                    }
                }
                else // real key-value-pair
                {
                    values.Add(current.Path, current.ToString());
                }
            }

            return values;
        }

LG

PS: Zur Nutzung - ein solche RessourcenDatei sollte sich immer mit JObject parsen lassen - JObject ist zudem ein JToken und kann somit komplett in die Methode gegeben werden.

PPS: Wenn ich mir deinen Code gerade anschaue solltest du dir für das Thema Typ-Vergleich dringend die Ausdrücke "is", "as" und "typeof" anschauen.

Hi,

na wenn das so ist würde ich persönlich wohl komplett diese verschachtelte Struktur aufbrechen. Du könntest auch durchaus ein Dictionary aus dem "MasterFile" erstellen, dass als Key den kompletten "Pfad" (also z.B. MyNameSpace.MyObject.MyProperty) hat.

Danach sollte ein Vergleich auf überschreibende Werte sehr einfach sein.

Damit hat man sich die Prüfung leicht gemacht und kann auch leicht Bescheid sagen was sich eventuell beißen würde.

LG

Wie sagt man so schön:
"So oft wie nötig, so selten wie möglich"

Es ist natürlich Unfug ein Member x-fach zu prüfen, wenn man von vornherein sicherstellen könnte, dass kein Unsinn drin steht. Bei Formularvalidierung würde ich genau ein einziges mal bei der Validierung prüfen - bei Schnittstellen kann das allerdings auch sehr viel häufiger auftreten.

LG

Hi,

mal ab von den ArrayLists denke ich dein eigentliches Vorhaben lässt sich sicher besser machen.

Ich weiß nicht genau, was du eigentlich vorhast - aber normalerweise gilt:
a) Du weißt oder könntest wissen was du bekommst -> dann baut man ein C#-Objekt daraus
b) Du willst für nachgelagerte prüfen, ob das was kam überhaupt passt -> validieren -> für solche Fälle gibt es eine allgemeine Prüfung ob das korrektes JSON ist, für genauere Prüfungen gibt es JSON Schema

Gerade dein fixes Dictionary klingt für mich ehrlich gesagt nach einem Fall für JSON Schema, womit man eingehende JSON-Objekte gegen entsprechend formulierte Regeln gegenprüfen kann.

LG

PS: Nur weil JSON als Format nicht typisiert ist - sind die Dokumente noch lange nicht untypisiert in meinen Augen. Das Gegenteil ist in meinen Augen der Fall - JSON ist ein Austauschformat für Programme, die i.d.R. mit Objekten arbeiten - JSON ist also meist die Übersetzung eines Objekts, dass definitiv nicht untypisiert oder gar "nicht definiert" ist. Ähnlich wie bei XML gibt es Schemata, wobei diese bei JSON (zugegebenermaßen) noch sehr selten auch explizit veröffentlicht werden.

Hi,

den Upload-Filter halte ich technisch für eine der ungeschicktesten Methoden das Problem zu lösen. Ein solcher Filter nimmt von Natur aus zu viel raus und hat damit mehr als nur das Potenzial freies Wissen und Meinungsäußerung auszuhebeln bzw. zu behindern - das ist mehr eine natürliche Konsequenz. Ab davon verstehe ich nicht, weshalb man es derartig versucht.

Zum einen gäbe es technische elegantere und wesentlich weniger invasive Methoden wie die im Artikel genannte API - zum anderen - wer sind wir, dass wir ein Computerprogramm entscheiden lassen ob das nun eine Urheberrechtsverletzung ist oder nicht? Dafür gibt es unser Rechtssystem - und wer es für nötig hält es einzusetzen - dem wird auch heute bereits geholfen.

Obendrauf kommt, dass so eine Pflicht für Neuanfänger, Startups & Co. in meinen Augen einen absolut unfairen Nachteil darstellt - ist ja schön und gut, dass Facebook & Co. es sich leisten können eine solche Technologie neben dem eigentlichen Produkt zu entwickeln, weil diese schon längst groß genug dafür geworden sind - wer was neues aufbauen wollte und sowas auf's Auge gedrückt bekommt wird im Vergleich mit den großen in meinen Augen massiv benachteiligt.

Des Weiteren finde ich es unverhältnismäßig die Arbeit von Straftäter, Opfer, Anwälten und Gerichten jemandem auf's Auge zu drücken, der schlicht nichts dafür kann.

Zum Thema Fake-News:
Es ist ja vll nett gedacht - aber ich für meinen Teil habe aktuell ein massives Problem damit, wenn jemand vorschreiben kann was die Wahrheit ist lang bevor sich derjenige überhaupt sicher sein kann, dass dem so überhaupt ist. (Das bietet in meinen Augen schlicht zu viel Missbrauchspotenzial und gefährdet bereits im Grundsatz die Meinungsfreiheit) Zumal ich es in der heutigen Zeit ehrlich gesagt auch meist als vollkommen unangemessen betrachte, dass eine Seite die volle Wahrheit für sich beansprucht. Weiter gesponnen würde dadurch sogar die Wissenschaft massiv eingeschränkt - nur weil ggf. vor ein paar Jahren mit älteren Theorien, Messgeräten & Co. eine falsche Wahrheit definiert wurde.

Die einzig richtige Vorgehensweise hierzu wäre (Medien-)Bildung gewesen - aber so stellt man sich in der Tat auf eine Stufe mit Diktatoren - und das ohne jede Not.

LG

Hi,

der größte gemeinsame Nenner beider Klassen wäre dann wohl der DbDataReader.

Allerdings kann man Abt's Aussagen hier nur unterstreichen - du tust dir mit der Vorgehensweise keinen Gefallen sondern fällst nur später auf den Arsch.

LG

Hi,

ich denke das würde viel besser aussehen, wenn du Logik von Ansicht trennen würdest und entsprechend DataBinding einsetzt.

Ist aufgrund fehlender Komplexität hier zwar nicht wirklich erforderlich - aber man sollte es zum Lernen definitiv gleich richtig machen.

Was du noch einbauen könntest wäre ein etwas dynamischeres Notensystem im Sinne von:
Es gibt nicht nur Noten von 1-6 - sondern von 1-x. Wenn du's richtig machst kannst du dir einige Code-Dopplungen sparen (Double.TryParse - sollte eigentlich aber sicher eher int.TryParse ?) und machst eine dynamische Oberfläche.

LG