Forenbeiträge von xxxprod Ingesamt 1.378 Beiträge
Ich hab sowas selber noch nie probiert aber angeblich scheint das mit ClickOnce nicht möglich zu sein: How to include custom data files in ClickOnce deployment?
Aber eventuel hilft dir der Link hier weiter: How to: Include a Data File in a ClickOnce Application
Lg, XXX
Hallo Mary81,
könntest du bitte Code-Tags verwenden und den ganzen Programmcode hättest du auch nicht posten müssen.
ClickOnce kopiert soweit ich weiß immer nur die "relevanten" Files ins Zielverzeichnis. Ich glaube nicht, dass hier deine Dictionaries mitkopiert werden. Evt. musst du die unter Projekteigenschaften\Publish\Application Files noch einbinden oder manuell kopieren.
Lg, XXX
Meine Vermutung, das Bild mittels Dispose wieder freizugeben bevor du es erneut überschreiben kannst bestätigt sich in why does this code lock my files?.
Lg, XXX
Zum Lesen deiner Xml Daten: Ich hab zwar nirgends gelesen, dass man ein leeres DataTable verwenden muss, aber in allen (funktionierenden) Beispielen die ich gesehen habe, wird ein leeres verwndet. So auch hier in der MSDN: DataTable.ReadXml Method (XmlReader)
Eine Spalte aus deinem Datatable vergleichst du mit der Datenbank in dem du entweder die Spalte in die Datenbank kopierst und dort vergleichst oder die Spalte aus der DB in dein Programm holst und hier vergleichst.
Eventuel willst du ja auch mit DbDataAdapter arbeiten - der kann teilweise vollkommen selbstständig die Tabellen in der Datenbank anhand der Änderungen in einem Datatable aktualisieren.
Lg, XXX
Warum ReadXml nicht funktioniert kann ich dir nicht sagen und aber um etwas darüber sagen zu können müsstest du schon auch den Aufbau des Xmls und evt. der temp_DT posten.
zu deinem Id Vergleich: Du Vergleichst ob die DataColumn Namens ID der einen Tabelle ungleich der DataColumn Namens ID einer anderen Tabelle ist -> Natürlich; Sind doch zwei verschiedene Objekte.
Wenn du ungleiche Zeilen finden willst, musst du schon durch jede Zeile in haupt_DT.Rows die ID abrufen und sie in der temp_DT suchen. Entweder durchiterieren oder mit RowFilter.
Lg, XXX
Weil eine Wpf Anwendung eine Wpf- und keine Windows.Forms Anwendung ist. Ich habe bei meinem Projekt leider genau die selbe Konstellation und habe keinen Weg gefunden den Owner bei meinen Wpf-Windows zu setzen wenn das MainWindow ein WinForms Fenster ist.
Es gibt zwar allerhand Tricks und Tipps zu dem Thema aber wirklich funktioniert hat bei mir leider garnichts. Ich habs für mich so gelöst, das ich Modale Dialogfenster mit TopMost=true öffne, damit es nicht hinter das MainWindow fallen kann.
Wenn unerhofft doch jemand eine Lösung zu dem Problem postet würde mich das also auch sehr freuen. 😃
Lg, XXX
In form eines riesigen Fernsehers mit Touch in Besprechungszimmern wärs schon wieder praktisch - die ganzen Beamerlösungen, welche Handbewegungen an der Wand erkennen, funktionieren ja nur sehr bescheiden.
Vielleicht interessiert dich hierbei auch Zyan Communication Framework.
Lg, XXX
Ich verwende Commands mit der gleichen Implementierung aber ich verwende die CanExecute Methode bzw. das Event eigentlich nie - Ich verwende öfters eigene Properties, die dann über StyleTrigger evt. etwas disablen.
Ich finde die Implementierung mittels CommandManager.RequerySuggested auch eher unschön:
Es wird dann ja quasi für jeden Command der gerade in einer View steckt bei jeder Änderung die die View bemerkt ein CanExecuteChanged erzeugt oder? Zusätzlich bekommt der Command nichts davon mit, wenn sich dessen Zustand im Hintergrund geändert haben sollte.
Lg, XXX
Wo genau ist dein Problem? Was hast du probiert und was daran funktioniert nicht?
Wie dus angehen sollst willst du wissen? Schreib ein ItemTemplate welches abhängig von einem Zustand in deinem ViewModel das richtige Symbol darstellt.
Lg, XXX
Anderseits wünsche ich mir schon lange einen Schreibtisch, dessen gesamte Oberfläche ein Display ist.
Also das würde mir riesig gefallen. Wenn man die Sachen am Desktop dann auch "angreifen" könnte wärs noch cooler. Evt. ermöglicht das eine Technologie wie Leap Motion bald einmal.
Die Verwendung des Properties hättest du dir auch ergooglen können - in BasedOn wird natürlich ein anderer Style erwartet, welchen du zB mit StaticResource einbinden kannst.
Also
<Style TargetType="{x:Type ListViewItem}" BasedOn="{StaticResource {x:Type ListViewItem}}" >
<EventSetter Event="MouseDoubleClick" Handler="OrtsteileListViewDoppelklick" />
<EventSetter Event="MouseLeftButtonUp" Handler="OrtsteileListViewKlick" />
<!--<Style.Triggers>
<Trigger Property="ListViewItem.IsMouseOver" Value="True">
<Setter Property="Background" Value="Orange"></Setter>
</Trigger>
</Style.Triggers>-->
</Style>
Lg, XXX
Das BasedOn muss in den "darunterliegenden" Styles angegeben werden. Die Appl.xaml ist ja die höchste Ebene - wenn ein neuer Style den alten übernehmen soll dann braucht man dazu das BasedOn.
Auch muss man beachten, dass ein Property durch einen Style nicht mehr gesetzt wird, wenn dieses bereits durch einen manuellen Wert gesetzt wurde.
Lg, XXX
Gibt es denn keine passenden Events die bei der bestimmten Aktion die gewünschte Aktion ausführt? Ich finde deine Variante ein Dummy UserControl zu verwenden in der Situation nicht so schlimm, was stört dich daran?
//Edit: Hier hab ich was dazu gefunden: Über Trigger sollte es so möglich sein: Function call within XAML code?
Ich behaupte mal garnicht aber eventuel gibts ja alternive Möglichkeiten. Was macht die aufgerufene Methode in etwa und zu welchem Zeitpunkt soll sie aufgerufen werden? Vor, während oder nach dem Laden des Controls?
Lg, XXX
Du vermischt einfach Äpfel und Birnen - Bei einer TextBox gibt es keine Items zu selektieren.
Aber ließ und versteh doch was ich sagen will: SelectedItem kann nicht automatisch irgendwelche Zurodnungen treffen, wenn die Quell- und Ziel- Typen unterschiedlich sind.
Einen Vorschlag hab ich bereits gemacht indem du die Enumwerte auf Strings änderst.
Alternativ kannst du das DataTable typisieren und änderst die Spalte Anrede auf den Typ "Anrede" oder du baust im SelectedItem Binding einen Converter ein, welcher von String auf dein Enum und Retour konvertiert.
Das WPF so gscheit ist und von SelectedItem(Enum)->DataRow(String) zu konvertieren kann man annehmen nachdem jedes Objekt eine Methode .ToString() besitzt aber wie soll .NET im Umkehrschluß wissen, dass dein String im DataTable ein Anrede Typ ist???
Also die zwei(drei) Möglichkeiten hast du.
Lg, XXX
//Edit: Schwachsinn gepostet...
trotzdem: GetValues gibt keine Strings zurück sondern wie der Name schon sagt die Werte - Verwende stattdessen GetNames im DataProvider.
Und die ItemsSource der ComboBox ist eine DeinEnum[], String[]?
SelectedItem funktioniert nur, wenn quell und zieltyp identisch sind - du ladest gerade strings aus der Datenbank und hast aber EnumWerte(welche keine Strings sind) in deiner ComboBox. Ändere mal deine ItemsSource auf string[] dann sollte es denke ich hinhauen.
Lg, XXX
Wie wird ein Eintrag im Datatable selektiert? Listbox?
Was ist die DataSource "Grundlage" deiner ComboBox und Textboxen? Eine DataRow? Ein DataTable?
Was für einen Datentyp hast du denn im DataTable für die Spalte Anrede? Int, String oder explizit deinen Enum-Typ?
Was genau passiert denn(nicht) in der ComboBox? Wie hast du getestet, dass der Wert der ComboBox in das DataTable geschrieben wird und wie verhält es sich denn beim Laden der Werte?
Und für XML Code gibt es bessere Formatierungsmöglichkeiten hier.
Lg, XXX
Das PlayerModel sollte nichts von einem Track wissen - dafür hast du ja das TrackVM eingeführt:
PlayerVM -> TrackVM -> Track
Lg, XXX
Sind das auf der Grafik zwei Gruppen die jeweils die dichte Menge an Datenpunkten zusammenfassen oder 4 Gruppen?
Und wie hast du manuell diese Gruppierungen gesetzt? Wie bist du dabei vorgegangen? Kannst du dieses Vorgehen nicht direkt als Algorithmus umsetzen? Wenn nicht, warum nicht?
Ich verstehe deine Frage nicht wirklich - Dein Aufbau ist grundsätzlich so ok würde ich behaupten.
Meinst du, wie du im PlayerVM zu einem TrackVM kommst bzw. wie das TrackVM in das PlayerVM kommen soll? Hast du schon probiert dein Konzept umzusetzen? Evt. geht dir dabei der Knoten auf.
Lg, XXX
Ok das lässt sich in deiner Konfiguration so erklären:
Das liegt am UpdateSourceTrigger welcher im Standardfall "LostFocus" ist. Da du nur ein Control in deiner Testapplikation hast ist es auch unmöglich dass dieses eine den Fokus verliert und daher wird set und get nie aufgerufen. Füge noch einen Button oder eine andere Tb ein dann wird der Setter und Getter auch beim Verlassen aufgerufen.
Alternativ kannst du wie Quaneu bereits in seinem Code erwähnt hat UpdateSourceTrigger auf PropertyChanged setzen.
Lg, XXX
Genau deswegen funktionierts ja auch nicht - Wenn du jedesmal einen anderen oder den "richtigen" Wert zurück geben würdest, würde sich die Anzeige auch dementsprechend anpassen.
//EDIT: Antwort revidiert... muss nochmal drüber nachdenken^^
//EDIT²: Also ich hätte hier eine Vermutung:
Properties werden oft nach dem Schema implementiert um rekursive Aufrufe durch Changed Events zu verhindern:
set
{
if(_value != value)
{
_value=value;
// handle changed events
}
}
Ebenso merken sich die Properties der Controls ihre Werte und tun daher nur dann was, wenn sich wirklich etwas geändert hat und wenn das nicht der Fall ist, weil du immer den selben zurückgibst, wird natürlich der angezeigte Wert nicht verändert. Da kannst du noch so oft PropertyChanged feuern.
Lg, XXX
Alles was du dazu mMn. brauchst ist ein HierarchicalDataTemplate
lg. XXX
Hallo Quaneu,
ohne dein Problem mit gesharten Objekten in verschiedenen Auflistungscontrols jemals gehabt zu haben, verwende ich bei mir hin und wieder eine Lösung die dir hier ebenfalls helfen könnte:
Und zwar habe ich eine Wrapperklasse erstellt, welche das Objekt um die notwendigen "Gui-Spezifischen" Elemente erweitert.
z.B:
class MyListItem
{
public object Item{get;set;}
public bool IsSelected{get;set;}
}
In den Bindings musst du halt das .Item. noch zusätzlich anführen was aber mMn. kein Problem darstellen sollte.
Du müsstest halt dann in deinen ViewModels unterschiedliche Collections für die unterschiedlichen ListViews/TreeViews erstellen die jeweils eigene MyListItems haben die wiederum intern sich die gleichen Objekte sharen.
Lg, XXX
Ich würde nur die Informationen über die Termine speichern und dann mit geeigneten Abfragen die Daten live abrufen. Ich glaub nicht das die Vorberechnung von Terminen hier notwendig bzw. sinnvoll ist. Auch weil bei einem theoretisch unendlichem zyklischen Termin man unendlich viele Einträge generieren müsste sofern es kein maximales Datum in der DB gibt.
Lg, XXX
Ein Array ist aber ein Referenztyp und beim Übergeben des Arrays wird daher nur die Referenz auf dieses übergeben und nicht alle Werte extra kopiert.
Lg, XXX
//EDIT: Ansonsten kannst du auch deinen ValueType in einer Klasse kapseln und dieses Objekt dann überall verwenden.
//EDIT²: Letzteres wird dein Problem aber nicht beheben da eine Referenz auf einen Typen vermutlich mehr Speicher verbraucht als ein einfaches byte - Das Sinnvollste werden Arrays sein die du dann immer als "ganzes" übergibst.
Wie du bereits festgestellt hast geht das so über den Index nicht. Ich würde stattdessen lieber eine ID oder sowas aus deiner Datenzeile rausholen und die nachher beim Neubefüllen aus allen Zeilen raussuchen und zu selektieren.
Was du als Identifier in deinen Daten verwenden kannst musst du selbst definieren.
Lg, XXX
Warum fragst du den Index des Items nicht **vor **dem Clear ab?
Lg, XXX
Du kannst mit () groupieren und mit ?<> kannst du einer Gruppe sogar einen Namen zuweisen also kannst du mit
ID="(.*?)"
eine Gruppe erstellen die du dann unter Match.Groups abfragen kannst.
Lg, XXX
Du nimmst einen (Toogle)Button und aktivierst/deaktivierst (bzw. visible=true/false setzen) eine Textbox per Trigger. Um dann visuell auch noch dorthin zu kommen kannst du Templates überschreiben, Animationen einbauen usw. usf.
Lg, XXX
Entweder du hast 3x 1:1 Beziehungen, dann brauchst du auf beiden Seiten jeweils 3 Properties um entsprechend navigieren zu können. Oder du realisierst es als 1:n Beziehung und hast dann auf beiden Seiten nur eine Property. Auf der "1" Seite eine Collection und die Info ob Auswärts, Heimwärts usw. müsstest du dann ins Ranking einbauen.
Lg, XXX
Das Problem hat sich irgendwie erübrigt...
... ich wollte mittels Powershell Script und Process.CloseMainWindow() die Applikation schließen, was aber nicht funktioniert da diese kein Window besitzt(im Normalzustand). Ich wollte nicht gleich über Process.Kill() gehen weil der Weg etwas hart wirkt aber für diese TrayIcon in dem Fall vollkommen ausreichend, da es außer einen laufenden Timer im Hintergrund nichts macht außer warten. Beim Herunterfahren schließt es sich dagegen normal und blockiert Windows nicht, was ursprünglich meine Befürchtung und der Grund für den Thread war, somit hat sich das Problem jetzt erübrigt.
Bzgl. deines Hinweises 7.e.Q - ein manuelles Beenden wäre ja nicht das Problem gewesen ich aber ich wollte wie erwähnt die Applikation von außerhalb schließen lassen was aber ohne Window nicht funktioniert außer wie gesagt durch Process.Kill()
Lg, XXX
Hallo,
ich habe gerade ein Problem mit einem Program, dass sich durch Aufforderung von außen nicht schließt:
Es handelt sich dabei um ein Program das nur ein NotifyIcon anzeigt und bei Bedarf auch mal Windows aber prinzipiel wird es durch Application.Run() gestartet und hat dadurch kein "MainWindow" mit dem es sich schließen soll.
Mit welchen Events bekomm ich mit, dass dieses Program geschloßen werden muss, damit ich dann dort Application.Exit() aufrufen kann?
Vielen Dank für jede Hilfe,
XXX
Nachdem ein implizierter Operator statisch ist wirst du ihn weder in einem Interface noch virtuell in einer Basisklasse definieren können.
Was aber gehen sollte, wäre den Operator in einer Basisklasse anzulegen und beim Konvertieren Methoden des übergebenen Objektes aufzurufen:
So in der Art
public abstract class BaseClass
{
public static implicit operator int(BaseClass m)
{
return m.ConvertToInt();
}
protected abstract int ConvertToInt();
}
class BaseClassImpl : BaseClass
{
protected override int ConvertToInt()
{
return 5;
}
}
//Edit: Habs gerade getestet und tut auch das gewünschte. Natürlich gehören noch ein paar Checks rein aber das ist ein anderes Thema.
Hallo thorran,
was ist deine DataSource? Ein Array von was? Oder doch ein Datatable?
Bei einem DataTable würd ich dessen DefaultView dafür verantwortlich machen. Wenn dem so ist, kannst du für jede ComboBox eine neue DataView mit dem DataTable als Parameter erstellen und dann sollte die Navigation der ComboBoxen entkoppelt sein.
Lg, XXX
Die Besitzerspalte:
ID | CollectionID | AccountID | IstBesitzer
---------------------------------------
1 | 5 | 1 | Ja
2 | 5 | 7 | Nein
3 | 5 | 3 | Nein
4 | 5 | 10 | Nein
5 | 5 | 5 | Nein
6 | 6 | 2 | Ja
7 | 6 | 15 | Nein
8 | 6 | 37 | Nein
9 | 6 | 562 | Nein
10 | 6 | 4 | Nein
Ich möchte an dieser Stelle auch erwähnen, dass deine Namensgebung etwas unschön ist und man daraus schwer ein System verstehen kann. Gib den Tabellen sprechende Namen - was soll eine TextCollection sein?
Du meinst jeder Account kann zusätzlich mehrere Texte abspeichern? Dann erstellst du dazu eine neue Tabelle die für die Texte zuständig ist:
ID | AccountID | Text
----------------------------
1 | 1 | bla
2 | 1 | anderer Text usw.
Und mittlerweile muss ich auch noch auf [Hinweis] Wie poste ich richtig? 1.1.1 Nicht nach Grundlagen fragen hinweisen. Deine Probleme hier sind alle der Natur mangelndes Verständnis relationaler Datenbanken. Lies dich vielleicht zur Unterstützung in das Thema ERM ein.
Lg, XXX
Wenn du einen Besitzer wissen willst, kannst du eine weitere Spalte einführen, welches diesen kennzeichnet.
Dein zweites Problem hört sich nach einem neuen Problem an, welches mit dem ersten nichts zu tun hat.
Prinzipiell empfiehlt es sich schon wenn man mit Datenbanken arbeitet auch die Grundlagen von Entities und Relations kurz ERM zu verstehen.
In Linq2Entities würde so eine Abfrage dann ca. so aussehen:
Account hans = .... //Lade Hans
IEnumerable<Account> freunde = hans.CollectionAccount.Accounts;
oder
IEnumerable<Account> freundeVonHans = dataContext.Accounts.Where(a=>a.Name=="Hans").SelectMany(a=>a.CollectionAccount.Accounts);
Lg, XXX
Nein, siehe mein "edit"^^.
Die Abfrage, welcher Account ist mit wem befreundet sieht dann so aus:
select a1.*
from Account a1
join CollectionAccount ca1 on ca1.AccountID=a1.ID
join CollectionAccount ca2 on ca1.CollectionID=ca2.CollectionID and ca1.AccountID<>ca2.AccountID
join Account a2 on ca2.AccountID=a2.ID
where a2.Name='Hans'
und schon bekommst du alle Freunde von Hans.
Lg, XXX
Ich glaub jetzt hab ich dich verstanden:
Du hast aus meiner Sicht nur ein Beziehungsproblem bei der ersten Tabelle:
ID | Name
------------
1 | Hans
1 | Niels
ID
---------------------------------------
5
6
ID | CollectionID | AccountID
---------------------------------------
1 | 5 | 1
2 | 5 | 7
3 | 5 | 3
4 | 5 | 10
5 | 5 | 5
6 | 6 | 2
7 | 6 | 15
8 | 6 | 37
9 | 6 | 562
10 | 6 | 4
und die Beziehungen sehen dann genau so wie die Spaltenbezeichnungen aus:
CollectionAccount.CollectionID=>Collection.ID
CollectionAccount.AccountID=>Account.ID
Lg, XXX
/EDIT: Die Collection Spalte von der Account tabelle kannst du dir sparen, weil du den Account einfach auch in die Gruppe rein tust - siehe "hervorgehobene" Einträge in der CollectionAccount Tabelle
So ein System hab ich noch nie gesehen und es macht auch (zumindest in dem kleinen Beispiel hier) für mich keinen Sinn.
Was du hier erreichen willst ist eine klassische M:N Beziehung, welche durch eine Beziehungstabelle abgebildet wird:
ID | Name
--------------
1 | Hans
1 | Niels
ID1 | ID2
--------------
5 | 7
5 | 3
5 | 10
6 | 15
6 | 37
6 | 562
6 | 4
Und die Beziehung wäre:
Friendcollection.ID1 -> Account.ID
und
Friendcollection.ID2 -> Account.ID
somit kann jeder Account beliebig viele andere Accounts als Freund haben. 😃
Lg, XXX
Du kannst hier eine Überladung der Methode schreiben damit sie auch einen string entgegen nimmt und in der parst du den string und gibst rufst damit wiederum die erste Methode auf.
Lg, XXX
Hallo LuciLuke,
mit Regex könntest du das sicherlich gut abfragen und gleich zum Auswerten aufbereiten:
(?<Instruktion>benenne|erstelle)\s+(?<Subjekt>Disk|Folder)\s+(?<Name>(?:.(?!v))+)\s+(?<Preposition>vor|nach)\s(?<Wert>.*)
Die Gruppen sind benannt und haben die von dir gewünschte Reihenfolge.
Testen kannst du Regex Ausdrücke ausgezeichnet mit dem Tool hier: On-the-fly Regex-Tester: Regex-Lab
In C# kannst du dann ganz einfach auf die entsprechenden Gruppen der Reihe nach zugreifen und auswerten.
Lg, XXX
Eine reine XAML Lösung kann ich dir dazu nicht bieten aber hier ein Ansatz, wie ich es mit einem im MVVM umsetzen würde:
Du erstellst ein Attached Dependency Property wie folgt oder so ähnlich:
public class ListBoxDoubleClickBehavior
{
private readonly ListBoxItem _item;
private readonly ICommand _command;
private ListBoxDoubleClickBehavior(ListBoxItem item, ICommand command)
{
_item = item;
_command = command;
_item.Loaded += ItemLoaded;
_item.Unloaded += ItemUnloaded;
}
private void ItemLoaded(object sender, RoutedEventArgs e)
{
_item.MouseDoubleClick += ItemMouseDoubleClick;
}
private void ItemUnloaded(object sender, RoutedEventArgs e)
{
_item.MouseDoubleClick -= ItemMouseDoubleClick;
}
private void ItemMouseDoubleClick(object sender, MouseButtonEventArgs e)
{
if (_command.CanExecute(_item.DataContext))
_command.Execute(_item.DataContext);
}
public static readonly DependencyProperty DoubleClickCommandProperty =
DependencyProperty.RegisterAttached("DoubleClickCommand", typeof(ICommand), typeof(ListBoxDoubleClickBehavior),
new FrameworkPropertyMetadata(default(ICommand), DoubleClickPropertyChangedCallback));
private static void DoubleClickPropertyChangedCallback(DependencyObject d, DependencyPropertyChangedEventArgs e)
{
new ListBoxDoubleClickBehavior((ListBoxItem)d, e.NewValue as ICommand);
}
public static void SetDoubleClickCommand(UIElement element, ICommand value)
{
element.SetValue(DoubleClickCommandProperty, value);
}
public static ICommand GetDoubleClickCommand(UIElement element)
{
return (ICommand)element.GetValue(DoubleClickCommandProperty);
}
}
im XAML fügst du das Property dann per Style ans ListboxItem an:
<ListBox ItemsSource="{Binding Path=Items}">
<ListBox.Resources>
<Style TargetType="ListBoxItem">
<Setter Property="YourNameSpace:ListBoxDoubleClickBehavior.DoubleClickCommand"
Value="{Binding RelativeSource={RelativeSource AncestorType={x:Type ListBox}},
Path=DataContext.YourViewModelDoubleClickCommand}"/>
</Style>
</ListBox.Resources>
<ListBox.ItemTemplate>
<DataTemplate>
<StackPanel Orientation="Horizontal" >
<CheckBox IsChecked="{Binding Path=IsMyCheckBoxChecked}"/>
<TextBlock Text="{Binding Path=NameOfMyListBoxItem}"/>
</StackPanel>
</DataTemplate>
</ListBox.ItemTemplate>
</ListBox>
Und in deinem ViewModel kannst du dann im Command ganz bequem tun und lassen was du willst wie zum Beispiel das ViewModel deines ListBoxItems manipulieren:
YourViewModelDoubleClickCommand = new DelegateCommand(item =>
item.IsMyCheckBoxChecked = !item.IsMyCheckBoxChecked);
Lg und viel Spaß beim Werken,
XXX
Hallo herbivore,
stimmt, natürlich ist das Thema komplexer. Ich hab mir bei meiner Antwort nur die Zahlenwerte und das eine ungleiche Paar angesehen und hab daraus geschlossen, dass die Suche nach solch einem Unterschied recht einfach zu implementieren sei. Wenn man andere Kriterien für die Gleichheit heranzieht, funktioniert dieser Ansatz vermutlich nicht mehr so gut.
Lg, XXX
Rekursionen stell ich mir vor wie das Auslagern einer Teilberechnung einer Methode. Diese ausgelagerte Methode ist dann zufällig die selbe und wird halt nur mit anderen Parametern aufgerufen.
In dem Context der Methode sollte dich fast nur der Inhalt der Methode interessieren und nicht, was alle darauffolgenden Methodenaufrufe alles vollziehen.
Du musst dich also in die Methode hineinversetzen und versuchen deine Aufgabe zu erfüllen. Dabei wird eine unter-methode aufgerufen(sich selbst) und die liefert "irgendein" ergebnis, mit dem man weiterarbeiten kann oder nicht.
Ein rekursive Methode hat natürlich mehrere Aspekte und man muss sich jeden gesondert durchdenken. Aber das ganze auf einmal im Kopf zu haben ist mMn. nicht notwendig.
Wenns an der Verständlichkeit happert, ist die Methode eventuell nicht aussagekräftig genug gestaltet. Wenn die Methode einem versätndlichen Zweck dient, einen aussagekräftigen Namen hat und logisch Parameter mitführt, wird die Verwendung auch gleich viel klarer.
Vielleicht hilft das ja was 😃
Lg, XXX
Ich würd einmal annehmen, dass der Graph identisch ist, wenn alle Knoten identisch sind. Wo ist das Problem dabei den Graphen Knoten für Knoten zu vergleichen und auf unterschiede zu prüfen? Evt. musst du in unterschiedliche Richtungen suchen und bei einem Kreis dir merken, welche Knoten du schon geprüft hast.
Wenn du technische Probleme bei der Umsetzung hast, zeig was du bisher probiert hast und erklär woran du scheiterst.
Lg, XXX