Forenbeiträge von Lenny Ingesamt 95 Beiträge
Du könntest zwei virtuelle Comports nehmen -> USB zu Seriell Adapter
Hallo,
einer Freundin von mir ist es im Maschinenbaustudium genauso gegangen. Ist am nächsten Tag zu einem anderen Sachbearbeiter hin und siehe da, der Bericht wurde ohne Beanstandung angenommen.
Wäre vielleicht auch einen Versuch wert, meiner Erfahrung nach neigen Unis gerade bei sowas zu purer Willkür.
Von der Begründung die du erhalten hast, würde ich darauf Tippen, dass derjenige der das Abgelehnt hat sich mehr Theoretischen Hintergrund zu den von dir verwendeten Mitteln wünscht.
Würde aber auch noch mal nachfragen.
In C nennt man sowas eine Präprozessor Anweisung. In C# gibt es diese auch:
https://docs.microsoft.com/de-de/dotnet/csharp/language-reference/preprocessor-directives/
Braucht man dort nur eher selten bis gar nicht.
Man kann diese Anweisungen verwenden um zur Compilezeit einen bestimmten Codepfad auszuwählen oder z.B. mit #region eine einklappbare Region des Codes zu definieren.
In C/C++ hat der Präprozessor wesentlich mehr Verwendung und kann auch mehr als in C#.
Zu deiner eigentlich Frage:
Selbstverständlich kannst du das Symbol definieren:
#define HAVE_DATE_TIME_OFFSET
Steht aber auch alles in den Link oben drin.
Hallo,
ich hatte in meiner Bachelorarbeit auch einiges an Code produziert. (Allerdings C++) In Absprache mit meinem Betreuer habe ich wirklich wesentliche Code Abschnitte (so maximal 3-8 Zeilen) zur Verdeutlichung bzw. Illustration der im Text getroffenen Aussagen direkt in die eigentliche Arbeit eingebunden. Ich finde eine Beschreibung der Implementierung kann sonst sehr trocken werden unter Umständen.
Alle längeren Codesnippets (Aber bei weitem nicht der komplette Code) kamen in den Anhang. Da war aber auch kein Snippet dabei, das größer als eine DINA4 Seite war (LaTex formatiert)
Hätte ich die Arbeit direkt am Institut wo ich dann abgeben habe gemacht, hätte ich den kompletten Code dann auf CD beilegen müssen. Da ich aber extern die Arbeit geschrieben habe, wurde mir von dort untersagt, den kompletten Code dem Institut zu geben.
Hallo, willkommen im Forum.
Verwende doch das nächste mal bitte die Code Tags.
Dein Problem an der Stelle ist, wenn du
int[] zahlen = new int[] {a,b,c};
schreibst, dann legst du eine Kopie des Wertes an.
Du solltest dir zu dem Thema den Unterschied zwischen Referenz und Wertetypen durchlesen.
Das Problem ist, du kannst in C# keine Referenz auf einen Wertetyp speichern.
Was du machst kannst ist die Variablen in eine Klasse speichern und in dem Array die Klassen Referenzen speichern.
Also als Beispiel
class A
{
public int a {get;set;}
}
//In der Main
A[] array = new A[3];
A[0] = new A();
A[0].a = 1;
//und so weiter
Hallo,
das liegt daran, dass ein Array ein Referenztyp ist: Arrays (C#-Programmierhandbuch)
D.h. wenn du eine Methode hast du ein Array annimmt übergibst du ihr eine Referenz auf das Array und eben keine komplette Kopie des Arrays.
(So wie wenn du in C++ einen Pointer übergibst. Da übergibst du zwar die Kopie des Pointers aber der Speicherbereich auf den der Pointer zeigt ist der selbe)
Hey,
unter Linux kannst du per udev rule, ein bestimmtes USB Gerät (indem Fall ein bestimmter virtueller Comport) auf einen bestimmten Gerätenamen unter /dev mappen.
Eine einfache Beispielrule:
SUBSYSTEM=="usb", ATTRS{idVendor}=="03eb", ATTRS{idProduct}=="2424", GROUP="deine benutzer gruppe", SYMLINK="dein linkname für /dev"
Die Vendorid und Productid kannst du mit lsusb -v herausfinden. Die sollte für den Arduino eindeutig sein.
PS. du könntest das auch mit libusb machen. Da musst du nur auf die vendor bzw. product id abprüfen und dann direkt per usb Transfers in den virtuellen Comport reinschreiben 😉
for(int i = 0; i < 100;i++)
{
ListItem myItem = new ListItem(listItem1); //Oder mit geschweiften Klammern initialisieren
supercooleListe.Items.Add(myItem).
//Hier kann ich jetzt myItem verwenden
}
//Hier muss ich das Item aus der Liste raussuchen. Sprich durch die Liste iterieren und ein item mit dem Namen "listItem1" suchen.
Eventuell findest du irgendwo eine Tastatur die tatsächlich nur 2 Keys hat (Oder zumindest wenige Keys)
Das ganze ist in dem Fall ja keine C# spezifische Frage mehr. Einen Button der ein C# interface zum Auslesen findet wirst du vermutlich eher nicht finden.
Die Standard Lösung in dem Fall (Oder zumindest einen häufige Lösung) wäre:
Microcontroller -> Liest Buttonzustand aus -> Sendet diesen via Serieller Schnittstelle an den PC.
Für Seriell kann auch ein USB zu Seriell Adapter verwendet werden. Dieser sieht aus Programmierersicht am PC genauso aus wie eine herkömmlicher Serielport.
(https://msdn.microsoft.com/de-de/library/system.io.ports.serialport(v=vs.110).aspx
Und das hab ich selber vor einer Ewigkeit mal geschrieben:
http://www.roboternetz.de/community/threads/53894-Beispiel-Anwendung-C-Zugriff-auf-SerialPort)
Als Microcontroller kann man z.B. einen Arduino nehmen oder eine Selbstbaulösung auf Basis eines AVRs.
Hallo,
in Anlehnung zu meinem Beitrag von gestern ( Marshalling von struct Member in Klasse ) habe ich noch einige allgemeine Fragen zum Thema Marshalling die ich auch nach einigen vielen Stunden google nicht so richtig beantworten konnte.
Da die Fragen allgemeiner Natur sind habe ich einen extra Beitrag erstellt.
- Nested structs:
Wenn ich structs die aus simplen Typen bestehen in einander einbette muss ich dabei etwas bestimmtes beachten? Laut meinen Recherchen müsste folgendes problemlos funktionieren?!
struct A
{
int member1;
IntPtr member2;
....
}
struct B
{
int anotherMember;
}
struct C
{
A memberA;
B memberB;
}
- Arrays in structs. Wie kann ich folgende C Struktur in C# abbilden?:
typedef struct
{
float * data;
size_t size;
size_t capacity;
}A;
typedef struct
{
A memberA;
}B;
- Übergabe von structs an native Funktionen:
Angenommen ich habe eine native Funktion die ein struct A als void-Pointer animmt:
void doSomething(void * data);
Dann sollte meinen Recherchen nach folgendes funktionieren:
[DllImport(...)]
static extern void doSomething( ref A data);
//Aufruf
A dummy = new A();
doSomething(ref dummy);
Dieser Aufruf sollte ermöglichen, dass der C code das struct befüllen kann ? Als ich das Ausprobiert habe habe ich jedoch nur mit einer solchen Signatur ein befülltes struct zurückbekommen:
[DllImport(...)]
static extern void doSomething( [In,Out] A data);
//Aufruf
A dummy = new A();
doSomething(dummy);
Warum ?
Viele Dank im vorraus wenn mich jemand etwas zu diesem Thema aufklären könnte. Die MSDN ist zum Thema Marshalling gerade in komplexeren Fällen ziemlich schlecht finde ich.
Hey,
also ich habe jetzt paar Sachen geändert:
- Habe ich eine Basisklasse für meine Messages eingeführt damit ich die Methodensignatur für den Nativen Aufruf so ändern konnte:
[DllImport("librcl.so")]
extern static int rcl_publish(ref rcl_publisher_t publisher, [In, Out] MessageBase ros_message);
public bool PublishMessage<T>(ref MessageBase msg)
where T : MessageBase
{
int ret = rcl_publish (ref publisher, msg);
//Some Errorhandling
}
Hier bekomme ich jetzt aus dem native Code keine Fehlermeldungen mehr. Das [In,Out] hat also funktioniert. Danke 😃
- Ich bin jetzt dabei die Messages wieder zu empfangen. Dabei habe ich lustigerweise das Phänomen, dass das für Strings (Die auch nur ein struct mit einem IntPtr und einer Längen Info sind) und elementar Typen funktioniert. Jedoch nicht für Arrays.
Der C# Code dazu:
String:
[StructLayout(LayoutKind.Sequential)]
public struct rosidl_generator_c__String
{
public rosidl_generator_c__String(string _data)
{
size = (UIntPtr)_data.Length;
capacity = (UIntPtr)size +1;
data = Marshal.StringToHGlobalAnsi (_data);
}
public string Data{
get{return Marshal.PtrToStringAnsi(data);}
}
public int Size{
get{ return (int)size;}
}
public int Capacity{
get{ return (int)capacity; }
}
IntPtr data;
UIntPtr size;
UIntPtr capacity;
}
Für das Array (in dem Fall für floats):
[StructLayout(LayoutKind.Sequential)]
public struct rosidl_generator_c__primitive_array_float32
{
public IntPtr Data;
UIntPtr Size;
UIntPtr Capacity;
public rosidl_generator_c__primitive_array_float32(float[] _Data)
{
Console.WriteLine (Marshal.SizeOf<float> () * _Data.Length);
Data = Marshal.AllocHGlobal (Marshal.SizeOf<float>()*_Data.Length);
Size = (UIntPtr)(_Data.Length);
Capacity = Size;
Marshal.Copy (_Data, 0, Data, _Data.Length);
}
public float[] Array
{
get{ return Marshal.PtrToStructure<float[]> (Data);}
}
public int ArraySize
{
get{return (int)Size;}
}
public int ArrayCapacity
{
get{ return (int)Capacity;}
}
}
Die Verwendete Message sieht als C# code so aus:
Diese wird auch beim Aufruf von rcl_publish übergeben
[StructLayout (LayoutKind.Sequential)]
public class Dummy:MessageBase
{
[DllImport ("libtest_msgs__rosidl_typesupport_introspection_c.so")]
public static extern IntPtr rosidl_typesupport_introspection_c_get_message__test_msgs__msg__Dummy();
public System.Boolean thisisabool;
public System.Byte thisisaint8;
public System.SByte thisiauint8;
public System.Int16 thisisaint16;
public System.UInt16 thisisauint16;
public System.Int32 thisisaint32;
public System.UInt32 thisisauint32;
public System.Int64 thisisaint64;
public System.UInt64 thisisauint64;
public float thisafloat32;
public double thisisfloat64;
public rosidl_generator_c__String thisisastring= new rosidl_generator_c__String();
public rosidl_generator_c__primitive_array_float32 thisafloat32array = new rosidl_generator_c__primitive_array_float32();
}
Mein Problem jetzt: Beim String struct steht ein valider IntPtr usw. drin beim Empfangen, bei dem FloatArray steht jedoch bei allen 3 Werten nur 0 drin.
Die Auslese Funktion sieht so aus:
[DllImport("librcl.so")]
extern static int rcl_take(ref rcl_subscription_t subscription, [In,Out] MessageBase ros_message,[In,Out] rmw_message_info_t message_info);
public T TakeMessage<T>(out bool success)
where T: MessageBase, new()
{
T msg = new T ();
rmw_message_info_t message_info = new rmw_message_info_t();
int ret = rcl_take (ref subscription, msg, message_info);
//Some Errorhandling and returning the message + setting success parameter
}
Hey,
also um mal etwas auszuholen. Ich baue gerade einen .Net Wrapper für ROS2 (Robot operating system).
Bei ROS2 gibt es eine Messagedefinition aus der Code generiert wird. Im C Teil werden Messages als struct angelegt . Arrays innerhalb des Message-Struct haben einen eigenen struct typ, das nicht nur den Pointer auf die Daten enthält sondern auch noch eine Längen Information und eine Kapazitätsangebe.
Beispiel:
Gegeben ist eine Message die einen Int32 und ein Int32Array enthält (Für strings sieht diese Definition genauso aus nur eben dass ein char pointer verwendet wird):
Das Message struct sieht dann so aus:
typedef struct <message name>
{
int32 member1;
rosidl_generator_c__int32__Array member2;
}
Das rosidl_generator_c__int32__Array struct sieht so aus:
typedef struct rosidl_generator_c__int32__Array
{
int32* data;
size_t size;
size_t capacity;
}
Das struct, das die Message an sich repräsentiert würde ich gerne als Klasse abbilden und Anfangswerte setzen zu können, da die Messagedefinition auch Startwerte erlaubt.
Meine Idee war also ein Konstrukt wie folgt zu bauen:
struct rosidl_generator_cs__int32__Array
{
IntPtr data;
size_t size;
size_t capacity;
public rosidl_generator_cs__int32__Array(Int32[ ] _Data)
{
data = Marshal.AllocHGlobal (Marshal.SizeOf (_Data));
size = (UIntPtr)Marshal.SizeOf (_Data);
capacity = Size;
Marshal.StructureToPtr (_Data, data, true);
}
}
[StructLayout (LayoutKind.Sequential)]
class <message name>
{
Int32 member1;
rosidl_generator_cs__int32__Array member2;
}
Die Instanz der Message übergebe ich danach so an den native code:
[DllImport("librcl.so")]
extern static int rcl_publish(ref rcl_publisher_t publisher, IntPtr ros_message);
public bool PublishMessage<T>(ref T msg)
where T : class
{
IntPtr msg_ptr = Marshal.AllocHGlobal (Marshal.SizeOf (typeof(T)));
Marshal.StructureToPtr (msg, msg_ptr, true);
int ret = rcl_publish (ref publisher, msg_ptr);
//Some Errorhandling
}
Aus dem Native Code bekomme ich jedoch an einer Stelle die data auf einen null pointer überprüft immer eine native exception geworfen. Wenn ich die Message nur aus Elementaren Typen aufbaue funktioniert das auch Problemlos.
Man kann durchaus explizit eine Klasse kopieren beim Marshalling ( Marshaling Classes, Structures, and Unions ) . In der Doku wird dies auch entsprechend erklärt.
Warum B eine Klasse sein soll? Ich brauche Anfangswerte für bestimmte Variablen.
Mein Problem ist außerdem, dass anscheinend die Klasse richtig kopiert wird, aber nicht das darin enthaltene struct.
Hallo,
ich stehe im Moment vor dem Problem ein struct als Member einer Klasse an Native Code übergeben zu wollen.
Kurz zum Szenario -
Im Native Code sieht die Datenstruktur so aus:
#typedef struct
{
char* Member1;
int Member2;
...
}A;
struct B
{
int Member1;
A Member2;
}
In C# würde ich das Ganze gerne genauso abbilden, jedoch struct B als Klasse abbilden. Also so:
struct A
{
IntPtr Member1;
int Member2;
}
[StructLayout (LayoutKind.Sequential)]
class B
{
int Member1;
A Member2;
}
Ich habe jedoch keine brauchbaren Informationen gefunden wie ein struct als Member einer Klasse zu Marshallen ist bzw. ob / wie das überhaupt geht. Auf den Native Code habe ich keinen Einfluss.
Der Versuch dieses Konstrukt einfach an den Native Code weiter zugeben mit Marshal.StructToPtr resultieren darin, dass eine Überprüfung im Native Code mir mitteilt, dass Member1 keine validen Daten enthält (ein nullptr ist)
In deinem Code steht SWITCH_ SCREEN mit einem Leerzeichen.
Ansonsten überlege dir ob du Write oder WriteLine brauchst.
Das passiert sowie so.
Wenn du in einer (klassichen) Programmiersprache etwas in der Form schreibst:
Anweisung A
Anweisung B
Anweisung C
wird zuerst A, dann B, dann C ausgeführt.
Ich bin mir auch nicht ganz sicher was du meinst.
Eventuell bist du auf der suche nach:
if(...)
{
//Erste Bedingung
}
else if(...)
{
//Wenn die erste Bedingung nicht eingetroffen ist, frage diese Bedingung ab
}
else
{
// Wenn keine andere Bedingung eingetroffen ist, mache das hier.
}
Oder du bist auf der Suche nach einer Statemachine.
Hast du dir den Link überhaupt angeschaut. Dort gibt es genügend Beispiele.
Reicht das als Anstoß ?
WebClient.DownloadFile-Methode
Ansonsten: Wo willst du die Sachen runterladen? Von dem was du schreibst brauchst du ja auch ein Protokoll, dass es ermöglicht nur die Änderungen zu übertragen.
Hey,
wenn man sich das Inhaltsverzeichnis anschaut wird auf vieles wichtiges / grundlegendes eingegangen. Aber man kann anhand der doch sehr umgangssprachlichen Titel nicht wirklich sagen ob alle wichtigen Inhalte auch drin sind. Von daher eine erste Kritik, dass das Buch an dieser Stelle wohl nicht die allgemein üblichen Begriffe nennt.
Zum Inhaltlichen Vergleich kannst du auch mal hier schauen: http://openbook.rheinwerk-verlag.de/visual_csharp_2012/
Um einen Einblick in C# zu erhalten ist das Buch aber sicherlich ok. Man darf aber nicht erwarten danach einen Großteil des .Net Frameworks zu kennen.
Mir wäre das Buch insgesamt zu bunt und unübersichtlich, insbesondere wenn man später mal kurz was nachschlagen möchte.
Ich werfe dazu mal das hier:
http://docs.opencv.org/doc/tutorials/features2d/feature_homography/feature_homography.html#feature-homography
in den Raum.
Geht auch mit C# mit EmguCV
Google: Scope:
Variable (Programmierung)
Beschäftige dich mal mit den Gültigkeitsbereichen von Variablen.
Variable (Programmierung)
Dann solltest du schnell selber drauf kommen.
Lies dir doch bitte einfach die von mir geposteten Links durch. Dort steht das eins zu eins drin.
Dann verwendest du mkbundle falsch. Wenn du mono statisch dagegen linkst sind alle nötigen Libraries mit in der executable.
Hey,
was du auch noch versuchen kannst ist das tool mkbundle. Das generiert dir aus deiner Anwendung und mono eine einzelne Executable. Sollte für deinen Zweck ausreichen:
Für mehr Informationen siehe hier:
http://www.mono-project.com/docs/advanced/runtime/#bundles
Naja die Idee dabei ist doch, dass man ein C Programm erstellt, dass die komplette Mono Runtime enthält in die dann dein C# Code geladen wird.
Und die nötigen Schritte dazu werden auch im Artikel beschrieben.
D.h. erstell dir eine main.c Mit dem Code wie unter: Initializing the Mono runtime
Danach kompilierst du das unter Linux mit:
gcc main.c pkg-config --cflags --libs mono-2
Und es sollte eine executable dabei rausfallen.
Hi,
das verrät dir ein kurzer Blick in die MSDN:
https://msdn.microsoft.com/de-de/library/6sh2ey19%28v=VS.110%29.aspx
z.B. remove:
https://msdn.microsoft.com/de-de/library/cd666k3e%28v=vs.110%29.aspx
Ich denke mal nicht, dass du hier im Forum die Unterstützung erhalten wirst die du dir erhoffst.
Es mag zwar einige Leute geben die sich mit der Thematik befasst haben, letztendlich ist es aber ein Themenkomplex der von dir intensive Einarbeitung erfordert, nicht was man mal schnell in einem Post klären kann. Das Forum ist wohl eher die richtige Anlaufstelle wenn es um Implementierungsdetails geht.
Du hast im Moment sehr toll Probleme formuliert, dir aber anscheinend noch keine wirklichen Gedanken zur Lösung gemacht. Es gibt gute Gründe warum nicht jeder mal Schnell eine KI oder eine Spracheingabe programmiert. Selbst mal für "einfache" Spiele ist eine KI alles andere als trivial.
Wenn dich das Thema wirklich interessiert wirf mal einen Blick in dieses Buch:
Künstliche Intelligenz (Pearson Studium - IT)
Zu deinem Autobeispiel. Es gibt bereit Computerprogramme die ziemlich zuverlässig Autos erkennen können, aber das als KI zu bezeichnen, darüber kann man sich streiten. Letztendlich überlegt man sich einen Haufen Merkmale und schaut wie viele man davon im Bild finden kann. So ähnlich macht ein neuronales Netz zu Bilderkennung das auch.
Hallo,
meines Wissens nach gar nicht (wenn nicht gerade der Schreibzugriff eine Exception wirft)
Du kannst auf eine serielle Schnittstelle auch dann schreiben wenn gar kein Gerät auf der anderen Seite angeschlossen ist.
Die einzige Art und Weise wie du das sicherstellen könntest, wäre in dem du z.B. den Parameter wieder aus deinem Gerät auslesen könntest.
Hey,
die böse Antwort wäre: Lerne C# programmieren und beschäftige dich mit Windows Forms.
Die nette Antwort: Ich habe da mal in einem anderen Forum ein Beispiel für den SerialPort mit C# und Windowsforms erstellt:
http://www.roboternetz.de/community/threads/53894-Beispiel-Anwendung-C-Zugriff-auf-SerialPort
Alternativ hier im Forum:
Dazu möchte ich aber anmerken, dass bei vielen Programmiersprachen die Unterstützung im Moment nicht über Syntaxhighlighting hinausgeht.
Microsoft hat aber angekündigt, dass auch für andere Programmiersprache die Unterstützung ausgebaut werden sollen und ein Pluginsystem eingebaut werden soll, dass die Integration anderer Sprachen erleichtern soll.
Auch das kannst du mit dem Debugger herausfinden.
Schau dir inylay bzw. den Rückgabewert von inlay.GetType() an und schau ob es dort eine passende Methode gibt.
Und damit hast du dir deine Frage auch selber beantwortet.
Anscheinend hat der Typ hinter dem Objekt inlay keine Methode Namens CreateImageInvoice.
Hallo,
schau dir mal das hier an:
http://www.pinvoke.net/default.aspx/winscard/SCardEstablishContext.html
Da sollte eigentlich alles erklärt bzw. eher gezeigt werden wie das geht.
Im Vergleich dazu die Daten in JSON Dezimal darzustellen sinkt sie aber. Dass ein reines Binärprotokoll effizienter ist, ist klar.
Hallo,
vielen Dank für die vielen Antworten. Insbesondere das BSON finde ich aufgrund der vielen bereits vorhandenen Implementierungen für andere Sprachen als interessante Alternative und werde mir das genauer anschauen.
Nun ist mir allerdings noch eine weitere Idee gekommen wie man die Übertragung effizienter gestalten kann und würde gerne eure Meinung dazu hören.
Man könnte beim bisherigen JSON bleiben und die großen Datenfelder binär z.B. in base64 codieren. Hierbei stelle ich es mir jedoch schwierig vor dem .Net JSON Serialisierer soetwas beizubringen ohne am Schluss selber großartig am String rumpfuschen zu müssen.
Hallo das Beispiel ist mir bekannt und die Möglichkeit eines eigenen Protokolls auch. Das war jedoch das was ich vermeiden wollte.
Deshalb hatte ich die Hoffnung auf beiden Seiten eventuell schon auf fertige Frameworks bzw. Libraries zurückgreigen zu können.
Hallo,
für eine Robotikanwendung suche ich eine effiziente, binäre Übertragungsweise für Daten zwischen einem Server der in C# geschrieben wurden und einem Client in Java. Im Moment ist die Kommunikation in JSON umgesetzt. Da allerdings nun die Anforderung besteht auch Bilddaten zu übertragen fällt JSON hierbei komplett aus.
Schön wäre es natürlich auf C# Seite WCF benutzen zu können. Auf Java Seite habe ich damit aber leider eigentlich nicht so richtig was gefunden.
Kann mir jemand von euch etwas gutes dazu empfehlen ?
Da das ganze ja nur ein OpenCv Wrapper ist aufjedenfall auch die OpenCv Tutorials bzw. Dokumentation:
docs.opencv.org/doc/tutorials/tutorials.html
Eine gute Möglichkeit ein Auto wie im von dir gezeigten Video zu erkennen, könnte sein auf Farbunterschiede im Vergleich zur Straße auf einem gewissen Bereich zu achten, eventuell mit einer Filterung nach Form davor. Du hast in diesem Szenario ja immer gleiche Belichtungsverhältnisse und eine feste Kameraausrichtung.
Hey,
- Referenzen, Werte
Am schönsten finde ich wird das bei C++ klar
https://de.wikibooks.org/wiki/C++-Programmierung/_Weitere_Grundelemente/_Prozeduren_und_Funktionen#call-by-reference
Für C# gibt es das aber auch schön in der MSDN erklärt:
https://msdn.microsoft.com/de-de/library/4d43ts61%28v=vs.90%29.aspx
- Zum Thema übergeben.
Genau das wird doch in dem Artikel zu Kommunikation zwischen 2 Forms erklärt.
Es ist nicht sinnvoll im Child Form das Hauptform zu kennen (Aus mehreren Gründen die man auch im Internet findet)
Wenn du vom Hauptform auf das Childform zugreifen willst, definier dort eine Methode die du von der Hauptform aus aufrufst.
Wenn du im Hauptform Daten aus der Childform brauchst, definiert im Childform ein Event, das du in der Hauptform abonnierst.
Warum solltest du deinem Hauptfenster eine Referenz auf das form_neueLinie geben.
Da ist diese Fehlermeldung nicht verwunderlich.
Vorallem habe ich das Gefühl du hast den Artikel nicht so richtig verstanden. Bzw. was dein Code macht. Anstatt dem Konstruktor das Form mitzugeben:
public form_Hauptfenster(form_NeueLinie f2)
Wäre die Gleiche Funktionalität erreicht wenn du.
public form_Hauptfenster()
{
InitializeComponent();
this.f2 = new from_NeueLinie();
}
Das war jetzt nur. Wie bekomme ich den Code mit der gleichen Funktionalität wie der gepostete zum Laufen.
Zum Thema: Wie bekomme ich von der Child Form wieder Variablen zurück, liest du noch mal den Artikel und schaust dir an den Teil zu Events an.
Die Grundidee dabei ist: Erzeug in deiner Hauptform deine Childform. Dieser Form gibts du Methoden mit um Variablen zu setzen. (Nicht die Hauptform im Konstruktor übergeben, oder umgekehrt).
Wenn sich in der Childform was geändert hat benachrichtigt diese die Hauptform über ein Event.
Ich möchte mich an dieser Stelle mal einklinken aus reiner Wissbegierde.
Sofern ich das richtig verstanden habe ist es doch möglich einen Pointer auf ein bestimmtes Benutzerelement eines anderen Programms zu erhalten (das in .Net) geschrieben wurde.
Sofern ich weiß wird auch in .Net ein Objekt an einer bestimmte Stelle im Speicher abgelegt auf die ich mit einem Pointer zugreifen kann.
Warum ist es dann also nicht möglich den erhaltenen Pointer in eine Textbox (o.Ä) zu casten ?
Also der Code funktioniert. Den habe ich nämlich vor einer halben Ewigkeit mal auf Roboternetz.de gepostet.
Dein Problem könnte eher darin liegen, dass du nämlich nicht verstanden hast was der Code macht
geschweige denn Diskussion dazu gelesen hast:
http://www.roboternetz.de/community/threads/53894-Beispiel-Anwendung-C-Zugriff-auf-SerialPort
Dort wird nämlich z.B. erklärt, was man macht, wenn die Antwort kein "Newline" Zeichen enthält.
string RecievedLine = " ";
while (RecievedLine != "")
{
RecievedLine = serialPort.ReadLine();
lbRecieved.Invoke(lbRecievedDelegate,new object[]{RecievedLine});
}
Wenn deine Antwort eben kein "Newline" hat, dann wird er ewig an der Stelle hängen bleiben.
Hallo,
ich habe in einem Blog folgenden schönen Artikel gefunden, der auch im Heise Forum bereits diskutiert wurde.
Favor Composition Over Inheritance part 1
Favor Composition Over Inheritance part 2
Dieser Artikel legt nahe, dass Vererbung ein "veraltetes bzw. schlechtes Prinzip" sei und man nur Composition mit Interfaces nutzen sollte.
Allerdings habe ich das Gefühl, der Artikel beschreibt die Realität nur etwas einseitig.
Nun wollte ich von euch wissen wie ihr es damit haltet, bzw ob ihr Vererbung als genauso "böse" anseht wie der Autor ?
Mir geht es in dem Fall nicht um ein spezielles Problem sondern nur um allgemeine Wissenserweiterung.
Hallo,
ich hatte ein ähnliches Problem bei mir schon lokal unter Visualstudio.
Dort ist es mir passiert, dass mein Programm samt Debugger abgestürzt ist und der compiler danach nicht mehr die Exe Datei überschreiben konnte. Bei mir hatte es geholfen die Exe Datei einmal von Hand zu löschen.
Hallo,
was hindert dich daran unter die Zeile:
p1.Top -= 10;
Noch die Zeile
p2.Top -= 10;
Zuschreiben. Dann veränderst du die Position beider Panels um -10.
Aus Usability Sicht würde ich dir Raten so etwas komplett sein zu lassen. Das nervt den User nur.
Aus technischer Sicht könntest du dir ein Windows Form erzeugen mit Höhe und Breite des Desktops, ohne Rand mit halb transparentem Hintergrund und das ein und ausblenden.
Hallo,
wenn du schon eine Picture Box hast, kannst du doch einfach die Image Eigenschaft verwenden um das derzeit angezeigte Bild zu bekommen.