Forenbeiträge von cprogrammer Ingesamt 68 Beiträge
Oben wurde geschrieben: "Sobald der Code ausgeführt wird, lässt sich das mit einem Debugger rekonstruieren."
Wo und wie setzt du hier den Einstieg, denn du hast ja weder den Sourcecode, noch das pdb file ?
Insgesamt wäre es dennoch interessant zu wissen wie das funktioniert.
Die obfuscated Klassen sehen nach der Obfuscation beispielhaft so aus:
internal sealed class XYZ
{
internal SortedList<double, abc> Name { get; set; }
[MethodImpl(MethodImplOptions.NoInlining)]
internal YXZ()
{
}
[MethodImpl(MethodImplOptions.NoInlining)]
internal void Method1(XYZ name zone)
{
}
[MethodImpl(MethodImplOptions.NoInlining)]
internal void AddMethod()
{
}
[MethodImpl(MethodImplOptions.NoInlining)]
internal void RemoveMethod()
{
}
[MethodImpl(MethodImplOptions.NoInlining)]
static XYZ()
{
<AgileDotNetRTPro>.Initialize();
<AgileDotNetRTPro>.PostInitialize();
}
}
Also alle Methoden leer und die untere Methode wird aufgerufen.
Als Assemly existiert eine AgileDotNetRTPro.dll, welche mit dem ursprünglichen Projekt nix zu tun hat.
Die letzte static Methode wurde hinzugefügt.
Hallo, normalerweise werden bei Obfuscation ja codeteile verändert, aber sind (mit gewissem Aufwand) immer noch lesbar.
Hier ist etwas, was scheinbar bullet proof ist.
Alle Methoden der Applikation sind leer und gekennzeichnet mit:
[MethodImpl(MethodImplOptions.NoInlining)]
protected override void OnConnectionStatusUpdate(ConnectionStatusEventArgs status)
{
}
zu den Referenzen gehören u.a.
kernel32.dd
AgileDotNetRT64Pro.dll
AgileDotNetRTPro.dll
Letztere dll stellt eine Klasse mit Methoden bereit, mit denen die eigentliche (geschützte) Applikation scheinbar Initialisiert und geladen wird, fraglich ist nur wie und von wo, letztlich wird sie ja ausgeführt:
internal static IntPtr Load()
{
WindowsImpersonationContext windowsImpersonationContext = WindowsIdentity.Impersonate(IntPtr.Zero);
Type typeFromHandle;
Monitor.Enter(typeFromHandle = typeof(global::<AgileDotNetRTPro>));
string text = ((IntPtr.Size != 4) ? "AgileDotNetRT64Pro.dll" : "AgileDotNetRTPro.dll");
string text2 = Path.Combine(Path.GetDirectoryName(new Uri(Assembly.GetExecutingAssembly().CodeBase).LocalPath), text);
if (!File.Exists(text2))
{
text2 = text;
}
IntPtr result = LoadLibraryA(text2);
windowsImpersonationContext.Undo();
Monitor.Exit(typeFromHandle);
return result;
}
internal static int InitializeThroughDelegate(IntPtr P_0)
{
IntPtr intPtr = Load();
IntPtr procAddress = GetProcAddress(intPtr, "_Initialize");
global::InitializeDelegate initializeDelegate = (global::InitializeDelegate)Marshal.GetDelegateForFunctionPointer(procAddress, typeof(global::InitializeDelegate));
return initializeDelegate(P_0);
}
Kann jemand was dazu sagen, wie das hier funktionieren könnte, wäre zu Lehrzwecken schon recht interessant ?
Ich arbeite mit einer dll und m.E. ohne Windows Forms.
Wenn ich WindowsBase mit using einbinde, dann meckert er auch und sagt es sei "unnessesary".
Im Projekt unter Frameworks - Microsoft.NetCore.App ist WindowsBase vorhanden, ja, und auch SystemWindows.
Ja, hatte ich ja auch geschrieben, dennoch kennt es der Compiler nicht, siehe Bild.
using System.Windows.Input;
public override bool ProcessKeyDown(KeyEventArgs e)
{
if (e.Key == 38)
{
}
return true;
}
Der Compiler meckert, dass er Key nicht kennt und dies angeblich in WindowsBase vorhanden sei.
WindowsBase ist aber nicht Teil meiner Assemblies, dafür aber System.Windows.Input, und dies definiert doch enum Key.
https://learn.microsoft.com/de-de/dotnet/api/system.windows.input.key?view=windowsdesktop-7.0
Woran kann das liegen ?
Hi, es gibt leider keinen Link zu einer API 😉 ich lebe hier quasi von dem was ich im Obkjektbrowser finde.
Aber danke für den Artikel, flags sind halt immer global und das wollte ich vermeiden.
Hallo TH69,
erstmal danke für deine Hinweise.
Das Ganze sieht aktuell so aus:
public override bool ProcessMouseDoubleClick(RenderControlMouseEventArgs e)
{
Funktion1; // Wird korrekt ausgeführt und ruft OnEvent auf und übergibt ihm _variable, s.u..
}
protected override void OnEvent(Klasse _variable)
{
Funktion2; // Wird korrekt ausgeführt und ruft ebenfalls OnEvent auf und übergibt ihm neue _variable, s.u..
//Spätestens jetzt haben wir m.E. eine Rekursion, weil innerhalb OnEvent, OnEvent aufgerufen wird.
Funktion3; // Wird nicht mehr ausgeführt.
}
Problem ist jetzt, dass jede Funktion denselben eventhandler aufruft, nur mit unterschiedlichen variablen, und damit dieser dann bei Funktion2 sich selbst.
Das führt zu dem Problem, dass Funktion 3 gar nicht mehr ausgeführt wird.
Wie könnte man das lösen ?
Ja, jede Methode 1 ... x löst einen Event aus, der mittels des Eventhandlers "behandelt" werden kann.
Die Methoden 1 ... x werden nacheinander aufgerufen, demgemäß müssten dann die zugehörigen Events auch nacheinander auftreten.
Du meinst also im Eventhändler könnten man quasi symbolisch schreiben:
if (Func1 ausgeführt) Methode2;
if (Func2 ausgeführt) Methode3;
etc.
Die von mir verwendete Klasse bzw. das zugehörige Interface sieht abgekürzt so aus:
public interface ITradingManager
{
.....
event Action<Order> NewOrder;
void OpenOrder(Order order, bool setDefaultQuantity = false);
...
}
Methode OpenOrder führt zum event NewOrder und das Event liefert eine Instanz von Order zurück.
Man könnte dann z.B. prüfen ob Order = Active usw.
Leider ist vieles was ich hier mache miserabelst bis gar nicht dokumentiert.
Zitat von Th69
M.E. wäre es angebrachter, herauszufinden, wo die Einstellungen gespeichert sind, anstatt diese aus einem Optionsdialog herauszulesen (denn dazu muß dieser ja im laufenden Programm auch geöffnet sein).
Hallo,
Der Dialog ist geöffnet, davon kann man ausgehen. Er wird soll durch die geplante Anwendung geöffnet werden
Herauszufinden wo die Properties des Dialopges gespeichert sind löst das Problem in diesem Falle nicht, weil der Dialog mittels der geplanten Lösung konfiguriert und "ferngesteuert" werden soll.
OnEvent ist der Eventhandler, welcher durch eine Action aufgerufen wird, wenn die erste Funktion ausgeführt wurde und der Server geantwortet hat.
Wenn ich die 2. Funktion in OnEvent aufrufe, dann muss ich die Aufrufe der beiden Funktionen ja verteilen auf meine Mausklickfunktion (Funktion1) und OnEvent (Funktion2), wenn ich dich richtig verstehe. Da es später ggf. noch weitere solche Funktionen gibt (Funktion3 etc.), tritt aber dann ggf. dasselbe Problem in OnEvent auf.
Der ersten Funktion wird keine Action o.ä. übergeben. Die Funktionen 1 und 2 rufen wiederum Methoden einer Klasse X auf, welche die Action auslöst und die Daten an den Server sendet.
Aber: die Action ist als Klassenmember der Klasse X vorhanden, wie ich sehe.
Könnte man das damit so lösen, dass alle Funktionen in der Mausklickfunktion verbleiben und der Aufruf mittels der X.Events gesteuert wird ?
Ich befürchte halt, dass dann immer irgendwie auf ein "wait" hinausläuft, oder ich habe irgendetwas noch nicht verstanden.
Vielleicht könnte man auch mit mehreren Threads arbeiten ?
Hallo,
ich habe folgendes Problem.
Folgende Funktionen werden nacheinander ausgeführt:
public override bool ProcessMouseDoubleClick(RenderControlMouseEventArgs e)
{
Funktion1;
Funktion2;
}
Dabei tritt ein Handshake-Problem auf, weil zunächst ein externer Server die Ausführung von Funktion1 bestätigen müsste, bevor Funktion2 ausgeführt werden kann (sollte).
Gelöst habe ich das Problem zunächst mit:
public override bool ProcessMouseDoubleClick(RenderControlMouseEventArgs e)
{
Funktion1;
Thread.Sleep(100);
Funktion2;
}
Natürlich sollten irgendwelche while-Schleifen oder verzögerungen etc vermieden werden, damit sich nix aufhängt.
Habt Ihr einen Hinweis, wie man das mittels eines Eventhandlers (wird über eine Action ausgelöst, wenn Funktion1 ausgeführt wurde) lösen könnte ?
Ziel wäre also, das Funktion2 erst dann ausgeführt wird, wenn Funktion1 "fertig" ist.
Da das Ganze aber auf Mausklick passiert und nicht etwa regelmäßig aufgerufen wird, ist mir schleierhaft, wie man hier z.B. mit flags o.ä. arbeiten könnte, die z.B. von einem Eventhandler gesetzt oder gelöscht werden.
Der Eventhandler sieht aktuell so aus:
protected override void OnEvent(Klasse _variable)
{
base.OnEvent(_variable);
}
Hi, besten Dank, der Support verweist bei soclhen Fragen darauf, dass dies über den Support hinaus geht 😉.
Mit der o.g. Funktion hat es leider nicht geklappt.
Aber ich habe nun über die von mir gefundene Klasse etwas gefunden, was ggf. funktionieren könnte, es fehlt mir nur noch ein "dependency Objekt".
In einem anderen Kontext (anderes Fenster) geht das so:
sdWindow = Window.GetWindow(this.UiWrapper.Parent) as NinjaTrader.Gui.SuperDom.SuperDom;
In meinem Kontext gibt es leider Probleme, siehe Bild.
Hallo, habe da was gefunden mittels Objektviewer.
Es wird eine Referenz auf ein Fenster Namens "Historical Data" benötigt, damit man auf die dortigen Properties zugreifen kann.
Es gibt eine entsprechende Klasse HistoricalData und u.a. eine Methode GetWindow(...) werden angezeigt.
Wäre das aus deiner Sicht eine Möglichkeit Alf ?
Falls ja, wie müsste man jetzt in der plugin dll vorgehen ?
Wenn ich die Klasse anlege dann wird GetWindow() leider nicht angeboten, siehe Bild.
Zitat von T-Virus
Ohne irgendwelche Informationen kann dir dabei keiner helfen.
Lies mal deinen Beitrag und stell dir die Frage, wie jemand ohne Wissen über deine Anwendung was dazu schreiben soll.
Ohne grundlegende Informationen was du für Einstellungen hast, wo die herkommen und wo die ggf. wieder gespeichert werden soll, hat man keine Informationen.Bitte liefere die mal nach, sonst wird es schwer hier irgendwas brauchbares sagen zu können.
T-Virus
Die Aufgabenstellung ist etwa vergleichbar mit der Frage, wie lese ich die Daten im Dialogwindow "Optionen" von Word aus, siehe Anlage.
Leider habe ich auch nicht viel mehr informationen, lediglich die installierte Applikation und die Dateistruktur dazu.
Die Daten werden sicherlich irgendwo gespeichert, da sie beim jedem Aufruf vorhanden sind.
Daher war ja die Frage wie man da grundsätzlich rangehen könnte und ob es irgendwelche Tools gibt, die hier weiterhelfen.
Hallo,
ich muss auf Daten einer Applikation zugreifen, für welche ich eine plugin dll erstelle.
Diese Daten werden von der Applikation über einen Dialog verwaltet und sind dot auch einstellbar/veränderbar.
Ich müsste nun die dortigen Einstellungen finden und einlesen und ggf. auch verändern.
Hättet Ihr da einen Tipp dazu wie ich da rangehen könnte ?
Ich hänge mal ein Bild an "myCode":
Tool1 isi ein erstes Anwendungsprogramm.
Tool2 ist ein zweites Anwendungsprogramm (selbe Funktion wie 1 nur andere API syntax).
Die Funktionalität beider Tools kann mittels plugin dlls erweitert werden.
Um nun zu verhindern, dass man diesselbe Erweiterungsfunktionalität zweimal programmieren muss, einmal mit API1 1 für Tool 1 und dann nochmal mit API 2 für Tool 2 würde ich gerne eine Art Interface dazwischenschalten, so dass die Erweiterungsfunktionalität unabhängig von der API der Tools programmiert werden kann und dann (möglichst einfach) an die APIs der Tools adaptierbar ist.
Wie so eine plugindll aussehen kann, z.B. für z.B. Tool1, seht ihr hier:
namespace ApplicationNamespace
{
public class MyName : Vererber
{
public MyName()
{
//My funktionality
}
protected override void OnDo1()
{
//My funktionality
}
protected override void OnDo2()
{
//My funktionality
}
protected override void OnDo3(ABC variable)
{
//My funktionality
}
protected override void OnDo4(int a)
{
//My funktionality
}
usw.
}
}
Ist bei beiden Tools sehr ähnlich, nur die Namen der Methoden unterscheiden sich teilweise.
Ich möchte quasi "My functionality" zunächst dll-unabhängig implementieren und dann später in die jeweilige API-Abhängigen Aufrufe reinbringen.
Ich nehme an, das man hier eine Art Zwischenschicht implementieren müsste (siehe IF im Bild), innerhalb derer man dann zwischen beiden Tools wählen kann.
Liege ich da richtig und hättet Iht hier einen Tipp, wie bzw. mittels welcher Herangehensweise man das realisieren könnte ?
Hallo,
hier ein Beispiel, wie ich DI verstanden habe.
class Program
{
private static void Main(string[] args)
{
var test = new List<string> { "A", "B", "C" };
var dosth = new DoSomething(test);//Dependency Injection
var input = dosth.Sort();
Console.WriteLine(input);
}
}
class DoSomething
{
IList<string> list; //Vermeidet Verwendungsabhängigkeit
public DoSomething(IList<string> arglist) //Vermeidet Erzeugungsabhängigkeit
{
list = arglist;
}
public string Sort()
{
return list[1];
}
}
Ausgabe: "B"
Es soll ja vermieden werden, dass die Klasse Objekte selbst erzeugt, sondern stattdessen diese vom aufrufenden Programm injiziert bekommt, falls sich das injizierte Objekt ändern sollte.
Man verwendet daher die Interfaces zur Übergabe.
Allerdings ist unklar, ob das z.B. im Falle von List oder anderen von der c# Bibliotheken bereitgestellten Klassen Sinn macht, denn deren funktionale Implementierung wird sich schon aus Gründen der Kompatibilität wohl nicht verändern, oder ?
Bei selbst erstellten Klassen kann ich mir das schon eher vorstellen.
Kurzes Feedback wäre nett (auch zu meinem Code 😉).
Hallo, ich arbeite an einer plugin.dll bestehend aus einer Klasse, die mit Leben gefüllt werden muss.
Die Funktionalität, d.h. der Funktionsumfang, wird zunehmend komplexer und umfangreicher.
Auch die Notwendigkeit zusätzlicher Erweiterungen ist vorhanden.
Ich lagere das teilweise in Klassen aus, welche dann in der dll instantiiert werden.
Mein Ziel ist allerdings eine leicht zu wartende Software, welche möglichst nicht ineinander verschachtelt ist und leicht erweitert werden kann.
Nun habe ich gelesen, dass es verschiedene "Design Pattern" für alle möglichen Zwecke gibt.
Hättet Ihr einen Tipp, womit ich mich idealerweise mal beschäftigen sollte, um mein o.g. Ziel ggf. besser in den Griff zu bekommen ?
Hallo,
hat jemand Erfahrung mit kostenlosen Installationstools und kann eines empfehlen.
Früher habe ich Installshield genutzt, da habe ich jedoch leiden keinen Zugriff mehr.
Letztlich geht es nur darum den Benutzer bei den Speicherung einer Datei in einem vorgegebenen Order (der sich bereits auf der Platte befinden sollte, d.h. das muss auch abgeprüft werden) zu führen und die Datei dort abzulegen. Ich möchte also dem Benutzer ersparen, das manuell tun zu müssen.
Hallo,
ich habe eine Liste mit aufeinanderfolgenden Sequenzen aus Nullen und Einsen, siehe Anlage.
Gibt es in C# und/oder Linq eine Möglichkeit mit der man herausfinden kann, wie lang die längste Sequenz aus Nullen oder Einsen ist ?
Hier wäre das Ergebnis: 4 aufeinanderfolgende Einsen.
Hier eine Klasse, mit der ich konfrontiert bin.
public class Test
{
List<TradeSetupCl> TradeSetupList = new List<TradeSetupCl>();
ctor: Erstes Element der Liste initialisieren mit Parameter X
Methode1: Fügt neue Elemente mit Parameter X zur Liste hinzu und wird zyklisch aufgerufen, solange das Programm läuft
Methode2: Ändert ParameterX so dass alle Elemente in der Liste neu berechnet werden müssem, unter Berücksichtigung von Parameter X
//Um dies zu erreichen wird Methode 1 wieder zyklisch aufgerufen
}
Ich vermisse hier einen Clear der Liste.
Kann hier ohne Clear der Fall auftreten, dass die Liste immer länger wird ?
Wo/Wann wäre hier ein Clear erforderlich ?
Zitat von Palladin007
Die Übergabe eines Externen Wertes als Methodenparameter an die Methode eines Objektes wäre also ok ?
Ich weiß nicht, was Du unter "externen Wert" verstehst.
Wenn Methode A eine andere Methode B aufruft, dann darf sie natürlich jeden Wert, der benötigt wird, als Parameter übergeben, dafür sind sie da.
Ich meine eine Variable, welche man der Methode bei ihrem Aufruf übergibt, die in der Klasse, welcher der Methode angehört, nicht vereinbart ist,
aber für die Berechnung erforderlich ist.
Alternativ wäre es ja möglich diese Variable vorab als Klassenvariable zu definieren und mittels Property zu übergeben. Wie die Variable "argmember".
Variante 1: Übergabe von argmember mittels Methode:
public class Test
{
public int Input {get; set;}
public int _input, _output;
public void Test(int argwert)
{
this._input = argwert;
}
public void Member(int argmember)
{
_output = Input * argmember / _input;
}
}
Variante 2: Übergabe von argmember mittels Property:
public class Test
{
public int Input {get; set;}
public int _input, _output;
publich int _argmember;
public void Test(int argwert)
{
this._input = argwert;
}
public void Member()
{
_output = Input * argmember / _input;
}
}
Zitat von Palladin007
Frage 1:
Wann weise ich den Klassenvariablen Werte per Konstuktor zu bei der Objektinstantiierung mittels
Wenn Du es brauchst, der Wert also vor "Lebensbeginn" des Objektes bzw. im Konstruktor benötigt wird.
Ich behandle das immer so: Alle Werte, die das Objekt benötigt, um grundlegend zu funktionieren, werden über den Konstruktor verlangt.wann erst nach der Instantiierung z.B. mittels direkten Ansprechens nach der Variablen mittels
Nie, weil immer Properties genutzt werden sollten.
Wenn ich die Frage auf Properties beziehe:Dann, wenn Du es brauchst und die Klasse damit umgehen kann.
Ich halte immer möglichst viel immutable, also möglichst kein Setter, demnach auch möglichst viel über den Konstruktor oder einer Kombination der beiden neuen Features "required" und "init".
Frage 2:
Wann wähle ich die Variante mit getter/setter wie oben bei "Input" und wann arbeite ich ohne getter und setter wie bei "_input" ?
Das heißt "Property".
Und alles, was public ist, ist eine Property.
Alles was private ist, darf auch eine Variable sein.
Nutz das, was Du brauchst.
Frage 3:
Methode und Methodenparameter.
Allerdings sollte die Methode das Ergebnis selber zurückgeben und nicht mit einer "_output"-Variable arbeiten.
Frage 4:
Die sind ein Thema, aber selten bzw. für besondere Situationen.
Für einen Anfänger sind sie aber wahrscheinlich irrelevant.
Danke für die Hilfe.
Kurz noch zu 3.
Test.Methode(ExternerWert)
Die Übergabe eines Externen Wertes als Methodenparameter an die Methode eines Objektes wäre also ok ?
Hallo,
hier hätte ich mal wieder ein paar (wahrscheinlich sehr doofe) Grundlagenfragen am Beispiel der nachfolgenden Klasse:
public class Test
{
public int Input {get; set;}
public int _input, _output;
public void Test(int argwert)
{
this._input = argwert;
}
public void Member(int argmember)
{
_output = Input * argmember / _input;
}
}
- Wann weise ich den Klassenvariablen Werte per Konstuktor zu bei der Objektinstantiierung mittels
Test _test = new Test(Wert);
und wann erst nach der Instantiierung z.B. mittels direkten Ansprechens nach der Variablen mittels:
Test._input = Wert;
2. Wann wähle ich die Variante mit getter/setter wie oben bei "Input" und wann arbeite ich ohne getter und setter wie bei "_input" ?
Test.Input = X;
Test._input = Y;
3. Kann man Members der Klasse so implementieren, dass man ihnen Variablen beim Aufruf nach der Instatiierung übergibt, welche in der Klasse selbst nicht definiert wurden, aber für ein Ergebnis erforderlich sind, oder sollte man diese Werte in der Klasse definieren und vorher übergeben z.B. mittels getters/setters und dann den Member aufrufen ?
Test.Member(ExternerWert);
var Ergebnis = Test._output;
4. Wann verwendet man "this" ?
5. Ist bei C# das Thema "Zeiger" überhaupt noch ein Thema oder muss man sich darum gar nicht mehr kümmern ?
Das ist nicht unsere Schuld.
Hat niemand behauptet.
Aber der Abschnitt hier lautet ja "Grundlagen c#", weshalb ist es dann anrüchig Grundlagenfragen zu stellen ?
Wenn ich ein spezifisches Problem habe kann es durchaus hilfreich sein einen Tipp zu bekommen, mit dem man sich dann selbst weiterhelfen kann, ein Verweis auf das gesamte C#-Werk erscheint mir da weniger effizient zu sein.
Aber grundätzlich hast du natürlich recht (wenn man Zeit hat, kann und sollte man von Null anfangen).
Ich meine doch nicht die offizielle c# doku, sondern die API-Doku, mit der ich zurechkommen muss und in der hunderte proprietäre Klassen und Funktionen zur Anwendung kommen, die teilweise auch noch obfuscated sind und die der Hersteller nicht beschreibt, und das für einen C# Neuling.
Zitat von Palladin007
var index = HorizontalLinesTillTouch.IndexOf(Entry); HorizontalLinesTillTouch[index] = Entry2;Oder Du machst die Entries mutable, kann unter Umständen besser sein.
Würde es dir etwas ausmachen an einem Beispiel kurz zu zeigen, wie man das "mutable" macht ?
Min Problem ist, dass ich mit meinen C/C++-Background in einem recht umfangreichen und schlecht bis gar nicht dokumentierten C# Umfeld (z.B. kaum vorhandene API doku) eine plug in dll entwickeln muss und in den Grundlagenveranstaltungen idr einfache Dinge wie Schleifen etc. vermittelt werden. Auch ist es für mich schwer die vielen möglichen und unterschiedlichen Schweibweise für Codeanweisungen unter einen Hut zu bekommen.
Hi, normalerweise codiert man properties ja so:
public NoTradeDay Monday { get; set;}
Nun muss ich aber die Memberfunktion RecalculateValues() unterbringen und dann geht das m.E. nur so:
NoTradeDay _monday = NoTradeDay.Ignore;
public NoTradeDay Monday
{
get
{
return _monday;
}
set
{
_monday = value;
RecalculateValues();
}
}
Oder gibt es da eine Akkürzung ?
Könnte mal bitte jemand in Worten erklären, was das alles bedeutet (ist kaum möglich zu recherchieren, wegen der Symbolik) ?
Die unklaren Statements sind gekennzeichnet !
public List<DeltaInfo> deltaInfos = new List<DeltaInfo>(); -> Klar !
for (int i=0; i<CurrentBar-1; i++) -> Klar !
{
var candle = GetCandle(i);
var delta = candle.Delta;
DeltaInfo item = new DeltaInfo()
{
Nubmer = i,
Delta = delta
};
deltaInfos.Add(item);
}
//Unklar
var positive = deltaInfos.Where(h => h.Delta > 0).Average(h => h.Delta);
var negative = deltaInfos.Where(h => h.Delta < 0).Average(h => h.Delta);
var ControlPositive = deltaInfos.Where(h => h.Delta > positive * Multiplier).ToList();
var ControlNegative = deltaInfos.Where(h => h.Delta > negative * Multiplier).ToList();
Ich will eine Klasse in einem Assembly (OFTPlatform.dll) nutzen, welches ich zu meinem Projekt dazugefügt habe.
Dann habe ich noch den namespace dazugefügt und die Klasse wird erkannt.
DrawingPosition drawingPosition;
Keine Fehlermeldung, aber das Objekt ist ja noch nicht initialisiert.
Wenn ich das Ding initialisieren will, siehe angehängte Datei für die Definition der Klasse im Assembly (DrawingPosition_1) und was beim initialisieren passiert in meinem Projekt (DrawingPosition_2).
OFTPlatform.dll gehört zu dem Program für das ich eine plug in dll baue.
Habt Ihr da einen Rat ?
Hallo, ich habe folgenden Code:
LineTillTouch Entry = new LineTillTouch(LastBar, _signalpriceL, myEntryPen, 2);
HorizontalLinesTillTouch.Add(Entry);
HorizontalLinesTillTouch ist in einer geerbten Klasse definiert als:
public List<LineTillTouch> HorizontalLinesTillTouch { get; } = new List<LineTillTouch>();
Nun werden fortlaufend Linien gezeichnet mit der Länge 2 (s.o. Entry oben).
Wie kann ich zu einem späteren Zeitpunkt das oben mittels Add zugefügte Element "Entry" mit der Länge 2
durch ein Element Entry2 mit der Länge variablen Länge x ersetzen ?
Entry2 entsteht zu einem Zeitpunkt, längere Zeit nach Entry, d.h. ist vorher unbekannt. Erst wenn es bekannt ist soll es Entry ersetzen.
Hierzu folgende Frage:
Ich habe ja die Vorgaben des 3rd Party Tools und arbeite an einer dll dafür, deren Aufbau ebenfalls vorgegeben ist und die Implementierung einiger abstrakter emberfunktionen erwartet.
public class OwnIndicator : Indicator
{
}
Innerhalb dieser Klasse muss ich auf Funktionen zugreifen, die von "Indicator" geerbt wurden.
Wenn ich nun mit Schichten arbeiten will, dann müsste ich m.E. Unterklassen bilden, welche ebenfalls auf Funktionen zugreifen, die von "Indicator" geerbt wurden. Das geht aber nicht, weil es nur eine solche Klasse geben darf, andernfalls müsste jede Klasse bestimmte abstract members implementieren, die eigentlich gar nicht mehr benötigt werden.
Daher die Frage:
Wenn ich Subklassen bilde, kann ich dann von meinem "OwnIndicator" erben, um dann wiederum auf die von "Indicator" geerbten Funktionen indirekt zugreifen zu können, also nach dem Motto:
public class Subclass : OwnIndicator
{
//Verwende Funktionen, welche die Klasse Indicator bereitstellt
}
Zitat von T-Virus
Ich bin nicht ganz sicher wie dynamisch deine Auswertungen werden können.
Wenn es hier auch Positionen geben kann, dann entfällt foreach, da du u.U. die genaue Position ermitteln müsstest.
Eine Liste wäre nur dann sinnvoll, wenn die Größe der Liste klein bleibt.
Ansonsten verbrauchst du u.U. viel Zeit nur mit dem durchlaufen der Liste und Auswerten der Fälle.
Dies könntest du zwar mit Linq bis zu einem gewissen Punkt erledigen.T-Virus
Folgende Abfrage funktioniert, wenn ich einfach nur wissen will, ob alle Kerzen diesselbe Richtung haben.
foreach (SimpleBarCl simpleBar in simpleBarList)
{
if (simpleBar.Bullish) j++;
if (j == simpleBarList.Count) ok = true;
}
Es soll aber auch geprüft werden, ob gemischte Richtungen vorhanden sind innerhalb der simpleBarList.
D.h. abhängig von der Position von simpleBar innerhalb von simpleBarList müsste geprüft werden, ob ein bestimmtes Muster aus gemischten bullishen oder bärischen Kerzen vorhanden ist.
Da ich aber nie weiss, wie der Count von simpleBarList ist, kann ich auch keine festen Positionen in simpleBarList abfragen, nach dem Motto
simpleBarList[0] == Bullisch && simpleBarList[1] == Bärish && Bullisch && simpleBarList[2] == Bullish etc.
Das funktioniert ja nicht, wenn z.B. nur 2 Objekte von simpleBar in simpleBarList vorhanden sind und ich ein drittes ansprechen würde.
Bei Linq sehe ich dasselbe Problem.
Habt Ihr da eine Idee ?
Eine normale for-Schleife nach dem Motto:
for (int i = 0; i <= simpleBarList.Count; i++)
tut es leider auch nicht.
Zitat von T-Virus
Dein Code sieht ziemlich C/C+ mäßig aus.
Get/Set Methoden werden in C# über Properties mit get/set umgesetzt.
Deine Methoden wäre als Properties vermutlich hilfreicher, solltest du entsprechend umbauen.
Den Ausdruck deiner if Abfrage kannst du direkt als return liefern, extra Abfragen mit return tue/false sind hier überflüssig bzw. redundant.
Hallo, wäre das so besser ?
internal class SimpleBarCl
{
private decimal _high;
private decimal _low;
private decimal _open;
private decimal _close;
private int _barnumber;
private bool _bullish;
private bool _baerish;
public int GetBarNumber { get; set; }
public bool Bullish
{ get
{
return _bullish;
}
}
public bool Baerish
{
get
{
return _baerish;
}
}
public SimpleBarCl(IndicatorCandle candle, int argbar)
{
_high = candle.High;
_low = candle.Low;
_open = candle.Open;
_close = candle.Close;
//_barnumber = argbar;
GetBarNumber = argbar;
if (_open < _close) _bullish = true;
else _bullish = false;
if (_open > _close) _baerish = true;
else _baerish = false;
}
}
Hallo, das ist kein Use Case ?
Ich möchte einen Kurschart analysieren und fortlaufend prüfen, ob (ausgehende von der jeweils aktuellen Kerze, siehe roter Pfeil), die vorherigen 1-x Kerzen bestimmte Kriterien erfüllen, relativ zur aktuellen Kerze gesehen und/oder relativ zueinander betrachtet.
Also z.B.: sind die vorherigen 3 Kerzen alle grün oder ist bei den vorherigen 10 Kerzen eine rote dabei, oder wie ist die Lage der vorherigen 6 Kerzen zueinander. Je nachdem wie viele Kerzen ich analysiere (das bestimmt der user) müssen diese variabel angelegt werden (dachte hier an eine Liste von kerzenobjekten),
Allerdings ist noch unklar, wie ich dann möglichst effizient die Kriterien prüfen kann, z.B. alle grün oder nur eine davon grün etc. speziell aber die Lager der Kerzen zueinander.
Ich möchte einen Kurschart analysieren und fortlaufend prüfen, ob (ausgehende von der jeweils aktuellen Kerze, siehe roter Pfeil), die vorherigen 1-x Kerzen bestimmte Kriterien erfüllen, relativ zur aktuellen Kerze gesehen und/oder relativ zueinander betrachtet.
Also z.B.: sind die vorherigen 3 Kerzen alle grün oder ist bei den vorherigen 10 Kerzen eine rote dabei, oder wie ist die Lage der vorherigen 6 Kerzen zueinander. Je nachdem wie viele Kerzen ich analysiere (das bestimmt der user) müssen diese variabel angelegt werden (dachte hier an eine Liste von kerzenobjekten),
Allerdings ist noch unklar, wie ich dann möglichst effizient die Kriterien prüfen kann, z.B. alle grün oder nur eine davon grün etc. speziell aber die Lager der Kerzen zueinander.
internal class SimpleBarCl
{
private decimal _high;
private decimal _low;
private decimal _open;
private decimal _close;
private int _barnumber;
public SimpleBarCl(IndicatorCandle candle, int argbar)
{
_high = candle.High;
_low = candle.Low;
_open = candle.Open;
_close = candle.Close;
_barnumber = argbar;
}
public bool Bullish()
{
if (_open < _close) return true;
return false;
}
public bool Baerish()
{
if (_open > _close) return true;
return false;
}
public int GetBarNumber()
{
return _barnumber;
}
}
List<SimpleBarCl> simpleBarList = new List<SimpleBarCl>();
for (int i = 0; i <= _barnumber; i++)
{
var _currentcandle = GetCandle(bar - i);
SimpleBarCl simpleBar = new SimpleBarCl(_currentcandle, bar - i);
simpleBarList.Add(simpleBar);
}
foreach(SimpleBarCl simpleBar in simpleBarList)
{
????
}
Hallo,
angenommen ich habe eine Klasse X und zur Laufzeit kann der User eine beliebige Zahl von z.B. 1-100 eingeben, welche vorgibt, wie viele Objekte der Klasse X zur Laufzeit angelegt werden sollen.
Die so angelegten Objekte sollen dann auch konfiguriert und analysiert werden.
Wie würdet Ihr hier vorgehen ?
Liste mit Objeten über for-schleife anlegen, die von 1 bis x läuft ?
Anschließend Liste mit foreach konfigurieren und auswerten ?
Also, so richtig schlau werde ich daraus nicht, zumal das irgendwie gescrambled zu sein scheint, Debuginfo für OFT.Platform.dll ist nicht vorhanden.
Könnte mal bitte jemand erklären was hinter folgenden Funktionen steckt (siehe Anlage):
GetFixedProfile
OnFixedProfilesResponse
Wenn ich in meiner Klasse von von Extended Indicator erbe und
GetFixedProfile aufrufe mit:
GetFixedProfile(new FixedProfileRequest(FixedProfilePeriods.LastDay));
sowie in
OnFixedProfilesResponse wie folgt implementiere
protected override void OnFixedProfilesResponse(IndicatorCandle fixedProfileScaled, IndicatorCandle fixedProfileOriginScale, FixedProfilePeriods period)
{
_candleKeyLevel = fixedProfileOriginScale;
}
und nach GetFixedProfile aufrufe, dann steht wie von Geisterhand in _candleKeyLevel (eine Variable in meiner eigenen Klasse) der richtige Wert.
Wie kommt der dahin und wie ist sichergestellt, dass der Wert nach Ausführung von GetFixedProfile gleich danach auch der richtige ist ?
Es hat wohl irgend etwas mit Actions oder Events zu tun, aber ich blicke es offen gestanden nicht.
Hallo,
ich verstehe folgenden Code nicht bzw. kann es nur erohnen:
Einmal hier:
base.DataSeries.ForEach(delegate (IDataSeries x)
{
(x as ValueDataSeries)?.SetPointOfEndLine(_targetBar - 1);
});
Delegate ?
Das "?" hinter (x as ValueDataSeries)
Und einmal hier:
DataSeries.ForEach(x =>
{
if (x is ValueDataSeries series)
series.SetPointOfEndLine(_targetBar - 1);
});
Der "=>"
Hier die Hintergründe:
private readonly ValueDataSeries _test = new();
DataSeries[0] = _Test;
public interface IDataSeries : INotifyPropertyChanged, INotifyPanelPropertyChanged
{
int Id { get; }
DataSeriesType Type { get; }
string Name { get; set; }
int Count { get; }
object this[int index] { get; set; }
event Action<int> Changed;
void Clear();
}
Zitat von T-Virus
Wie genau sehen die Varianten im Code den aus?
Klingt halt erstmal nach einem Interface mit unterschiedlichen Ableiten z.B. wie beim Strategie Muster.
Oder verstehe ich was falsch?T-Virus
Die Varianten beziehen sich auf den Funktionsumfang:
Beispiel:
Im Texteditor kann man in der Vollvariante Texte laden/schreiben/kopieren/einfügen.
Variante 1: Texteditor kann nur zum darstellen(laden) von Texten verwendet werden, schreiben und sonstiges nicht möglich.
Variante 2: Texteditor kann nur zum schreiben von Texten verwendet werden, laden und sonstiges nicht möglich.
Das Konzept für den Code wäre noch gestaltbar, ich würde natürlich versuchen die Funktionen so zu codieren, dass diese unabhängig voneinander aufrufbar sind. Aber das ist die alte Denke. Jetzt würde mich halt interessieren, wie man da mit c# rangehen würde, z.B. eine KLasse für jede Funktion oder eine Grundklasse mit allen Funktioenen, von der man dann Variantenweise erbt ?
Ziel 1 ist es, eine saubere Schnittstellen im Code zwischen den Varianten zu haben, so dass man auch aus Sicht des Codes Varianten einfach dazunehmen und weglassen kann (Modularität).
Ziel 2 ist es eine solche Variante dann möglichst einfach und schnell zu erzeugen.
Zitat von gfoidl
Steckst du gedanklich in C/C++ fest und hast den Sprung zu managed Sprachen / Runtimes wie C# und .NET noch nicht vollzogen?
Das ist definitiv so, komme aus der Assembler/C/C++ - Ecke und befasse mich gerade mit c#/.Net etc., daher auch hin und wieder Fragen, die für euch vielleicht heute keinen Sinn mehr machen (sorry), aber mir dennoch eine Antwort weiterhilft oder zumindest die Richtung aufzeigt.
Eine Frage ist z.B. auch, wie man hier z.B. den Funktionsumfang der dll variabel gestalten könnte.
Früher habe ich sowas mit Präprozessoranweisungen gemacht, aber da gibt es garantiert heute geschicktere Lösungen.
Beispiel:
Die .dll hat Funktionsumfang A;B;C
Variante 1 soll nur nur A,B haben
Variante 2 soll nur nur A haben
aber mein VS 2022 Projekt soll natürlich alle Varianten beinhalten.
Jetzt stellt sich die Frage, ob man variantenspezifisch compilieren kann, so dass die dll dann tatsächlich nur den varientenspezifischen code enthält, oder ob man den Funktionsumfang erst bei der Ausführung definiert (was natürlich die Gefahr beinhaltet, dass man ggf. mittels Tricks die Vollversion aus der reduzierten version macht).
Ich hatte mal irgendwo gelesen, dass man die gesamte dll gar nicht erst weitergeben müsste, sondern codeteile auslagern könnte, die dann erst während der Laufzeit durch einen "dll-Rahmen" vom Internet geladen werden, z.B. von einem eigenen server oder einer homepage. Quasi eine Art synamisches Linken übers Internet. Ist das machbar ?
Hab gegoogelt, aber nix mehr dazu gefunden, vielleicht hast du aber ein gutes Stichwort für mich 😉.
Könnte man z.B. eine dll in C/C++ programmieren und dann von einer .net Anwendung, die in c# programmiert wurde, verwenden lassen.
Falls ja, gäbe es da ein paar Tipps zur Vorgehensweise, insbesondere wie man die dll-Schnittstelle zum aufrufenden Programm gestalten müsste, dass das geht.
Hallo,
ich habe eine erste dll mit dem Hauptcode und eine zweite dll mit Subfunktionalität.
Die erste dll wird von einer vorhandenen Applikation (auf deren Code ich keinen Zugang habe) dynamisch eingelesen.
Da ich mit zwei dlls arbeite (auch um etwas Modularität und Übersicht zu behalten), ggf. kommt noch eine dritte hinzu,
wäre es nun erfordelich, immer alle drei dlls der Applikation zur Verfügung zu stellen, weil ja die erste die anderen aufruft.
Gibt es eine Möglichkeit die zweite und ggf. dritte dll mit der ersten dll so in VC 2022 zu verlinken, dass eine einzige dll
daraus resultiert.
Von früher kenne ich noch so etwas wie statisches und dynamischen Linken (C++).
Hier geht es jedoch um C# und ich habe dazu nix gefunden.
Es ist auch geplant, die Funktionalität der ersten dll bei Bedarf mittels dll's zu erweitern oder zu reduzieren, auch hier könnte das hilfreich werden.
Für Tipps/Richtungsweiser, wie ich meine Ziele:
- nur eine dll insgesamt
- funktionserweiterungen/funktionsreduzierungen der dll
erreichen kann, wäre ich sehr dankbar.
Hallo,
ich habe festgestellt dass der Dotfuscator Community - Visual Studio (Windows) (freie Version) im Prinzip
kaum etwas verschlüsselt. Sämtliche Klassen sind nach Anwendung bewärter Tool wie dotPeek etc. vollumfänglich sichtbar, lediglich einige
Codezeilen außerhalb der Klassen, welche diese Klassen benutzen, waren mittels kryptischer Strings umbenannt, die aber auch reletiv einfach nachzuvollziehen waren.
Gibt es irgendwelche Empfehlungen für Tools (idealerweise kostenfrei) mit denen man den gesamten Code relativ sicher (ich weiss, absolute Sicherheit gibt es nicht) scrambeln kann ?