Forenbeiträge von egrath Ingesamt 871 Beiträge
Hallo,
wie einige Vorredner auch schon sagten, ist es meiner Meinung nach so dass man in der Softwareentwicklung eigentlich nie auslernt. Der Syntax einer Sprache ist, wenn man die grundlegenden Konzepte (z.b. OOP) schon kannte relativ einfach gelernt, und dank umfangreicher Dokumentation kriegt man relativ schnell ergebnisse.
Zum "richtigen" Programmieren gehört jedoch viel mehr dazu - Dinge die man erst langsam lernt und bei denen das dazulernen eigentlich niemals abgeschlossen ist:* Welche Technologie verwende ich wann und wofür?
- Umsetzen von erprobten Design Patterns in eigenen Applikationen
- usw...
Dazu kommt natürlich noch dass sich unsere Welt der Technologie laufend verändert und wenn man mal in einer Technologie richtig Fit zu sein scheint, kommt schon der Nachfolger auf den Markt der sich damit rühmt noch besser, effizienter und schöner zu sein 😉
Dinge bei denen ich auch heute noch knabbere sind jene: Wenn ich z.b. wieder mal ein Monat lang an einem Java Programm arbeite und dann wieder nach C# zurückkomme - und umgekehrt. Viele Syntaxkonstrukte sind gleich, aber manche unterscheiden sich doch wieder; Und auf die macht dann einen der Compiler aufmerksam 🙂. Dazu kommt dann auch noch die Umstellung der unterschiedlichen Casings. Ich erwische mich immer wieder wenn ich in Java PascalCasing und in C# camelCasing für Methoden verwende....
Grüsse,
Egon
Hallo,
ich brauch dass, da ich aufgrund der Information ob ich mich im letzten element der aufzählung befinde noch ein Ausgabezeichen auf die Console schreibe oder nicht.
Natürlich könnte ich ein anderes Konstrukt dafür benutzen (Explizit den IEnumerator holen und iterieren, oder eine einfach for schleife benutzen), aber es geht mir darum ob es in einer foreach auch möglich ist.
Grüsse,
Egon
Hallo,
ich stelle mir gerade die Frage ob es möglich ist, innerhalb von einer foreach Aufzählung zu ermitteln ob noch weitere elemente vorhanden sind, oder ob ich mich schon beim letzten Element der Aufzählung befinde.
Geht das?
Leider hat definiert IEnumerator keine "HasNext" Property (das wär ja das schönste gewesen 😉
Grüsse,
Egon
Hallo,
Du bist genau auf einer der Methoden gestossen die erst kürzlich implementiert wurden 😉
Die von dir genannte Methode gibt es bei Mono erst ab Version 1.2.4, ich tippe mal darauf dass Du unter deiner Kubuntu Installation etwas älteres benutzt. Einfach mal eine aktuelle von www.mono-project.com runterziehen und beispielsweise nach /opt/mono installieren (configure --prefix=/opt/mono; make; make install). Dann müsste es funken.
Grüsse,
Egon
Hallo,
Mono implementiert beinahe den gesamten Umfang von .NET 2.0. Einige Dinge fehlen noch (z.B. bei WinForms), andere werden aufgrund von sinnlosigkeit im Unix Umfeld wohl gar nicht implementiert (WMI).
Dass Klassen und deren Methoden anders implementiert (in Bezug auf Funkionalität) sind kann ich nicht nachvollziehen. Gerade auf die Kompatibilität von Funktionalität wird grosser Wert gelegt. @capcom: Wenn Du etwas findest, dass anders funktioniert, eröffne bitte ein Ticket bei Novell, die freuen sich über solche Informationen.
Wenn Du allerdings Cross-Platform .NET Applikationen entwickeln möchtest, kannst Du auch den umgekehrten Weg gehen: Unter Mono Entwickeln und unter .NET ausführen. Die meisten Libraries sind auch für Windows verfügbar (z.b. GTK# als GUI)
Grüsse,
Egon
Hallo,
ich kann dir nur Evolution empfehlen. Ist zwar ursprünglich für Linux entwickelt worden, gibt es aber auch für Windows.
Grüsse,
Egon
Hallo,
ich muss sagen ich spiele sehr gerne. Früher eher weniger als jetzt, da ich zu hause eigentlich keine Lust mehr habe auch noch zu programmieren (10 Stunden in der Firma reichen 😉
Dabei eigentlich nur MMORPG's. Angefangen habe ich vor einigen Jahren (2001) mit Dark Age of Camelot, vor knapp zwei Jahren bin ich dann auf World of Warcraft umgestiegen. Wenn Freunde da sind, dann werden meist immer die Konsolen angeworfen - welche einer meiner Leidenschaft sind. Allerdings nicht die aktuelle Generation wie XBOX360 oder Wii sondern die älterne Geräte: Super Nintendo, Sega Saturn, Neo-Geo.
Spielen gehört einfach dazu.
Grüsse,
Egon
Hallo Haggy,
wenn Du vor englischer Literatur nicht zurückschreckst, kann ich dir nur folgenden Titel ans Herz legen:
Software Engineering, 8th Edition von Ian Sommerville
Einer der wenigen Schmöker bei denen es sich lohnt ihn von vorne bis hinten durchzuackern.
Grüsse,
Egon
Hallo Haggy,
für C# 3.0 hab ich mir vor einiger Zeit mal ein kleines Snippet zur übersicht geschrieben:
/*
* The new Features in C# 3.0
* use Mono > 1.2.5 and -langversion:linq to compile
*
* *) Implicity Typed Variables
* *) Anonymous Types
* *) Object Initializers
* *) Collection Initializers
* *) Extensions Methods
* *) Automatic Properties
*
* Lambda Expressions are not covered in this File
*/
using System;
using System.Collections;
using System.Collections.Generic;
namespace egrath.test.cs3
{
public static class CSharp3Test
{
public static void Main( string[] args )
{
// Implicity Typed Variables
var i = 3;
var j = "Hello, World!";
var k = new List<string>();
Console.Out.WriteLine( "{0}, {1}, {2}", i.GetType(), j.GetType(), k.GetType() );
// Anonymous Types
var anon = new { name="Egon", age=28 };
Console.Out.WriteLine( "{0}, {1}, {2}", anon.name, anon.age, anon.GetType() );
// Object initializers
InitTest it = new InitTest( "Initialize" ) { X=2, Y=4 };
it.Dump();
it = new InitTest { X=1, Y=2 };
it = new InitTest { Y=8 };
it.Dump();
// Collection initalizers
List<String> ls = new List<String> { "Hello", "World", "from", "C#", "3.0" };
foreach( string s in ls ) { Console.Out.WriteLine( s ); }
// Call a extended Method
Console.Out.WriteLine( it.Square() ); // Should print out 0
}
// Extension Methods
// Since we cant inherit from the Class "InitTest" (because it's marked sealed)
// we just have the option to extend it
static int Square( this InitTest it )
{
return it.X * it.Y;
}
}
sealed class InitTest
{
private string m_Message;
public InitTest()
{
m_Message = "blabla";
}
public InitTest( string message ) : this()
{
m_Message = message;
}
// Automatic Properties
public int X { get; set; }
public int Y { get; set; }
public void Dump()
{
Console.Out.WriteLine( "Message={0}, X={1}, Y={2}", m_Message, X, Y );
}
}
}
Grüsse,
Egon
Hallo beisammen,
ich wäre dafür dass wir bei Trivialfragen ganz einfach einen Link auf die entsprechende Seite einer C# Dokumentation (wie z.b. dem Guide to C#) posten und ein Moderator den Thread dann schliesst. Ob es sich um einen Trivialthread handelt kann ein Moderator meines erachtens selbst entscheiden, da er ja über genügend erfahrung in C# verfügt.
Damit wäre dann dem OP geholfen - weil er ja seine Antwort dort nachschlagen kann - und aber auch den restlichen Leuten die sich ansonsten ärgern müssen weil möglicherweise viele Leute ihre Kapazität mit dem beantworten solcher Fragen aufbringen.
Vor allem von dem Hintergrund her gesehen: Wieviele "echte" Trivial Threads haben wir den wirklich? Ich glaube es sind nicht extrem viele.
Grüsse,
Egon
Hallo haggy,
das war bei mir ähnlich. Alleine zu sehen dass der von einem entwickelte Code im Anschluss real vorhandene Hardware steuert ist faszinierend.
Als Einstiegsprojekt hatte ich mir selbst die Anforderung gestellt dass ein aus Technik Lego und NXT Komponenten gebauter Roboter (Kettenantrieb) folgendes bewerkstelligt:* Aufgrund einer eingegebenen Karte im gleichen Zimmer navigieren
- Ausweichen von unvorhergesehenen Hindernissen
- (Einen Kaffe von der Kaffemaschine runterdrücken)
Den letzten Punkt habe ich aufgrund von schwierigkeiten in der implementierung dann gehen lassen... 😉
Als Entwicklungsumgebung habe ich damals nicht das Robotics Studio verwendet (weil es das da noch nicht gab) sondern auf dem NXT das LeJos Betriebssystem aufgesetzt und dann in Java entwickelt.
Grüsse,
Egon
Hallo,
z.b. unter:
ansonsten einfach mal nach "NXT Sensors" googlen, gibt eine schier unendliche Anzahl von Anbietern dafür.
Grüsse,
Egon
Hallo,
die Boundaries werden immer in ganzen Blöcken angenommen - z.b. wenn dein MSIL Code die 4096 Byte grenze überschreitet dann wird der Block 8192 Byte groß usw. (Oder halt der eingestellte wert)
Grüsse,
Egon
Hallo,
das ist wegen dem Alignment des MSIL Codes auf Boundary Grenzen. Per Default ist diese auf 4096 Bytes eingestellt. Falls dein MSIL Code kleiner ist, wird der freie Platz mit NULL aufgefüllt. Wenn Du jetzt ein relativ kleines Programm hast (Hello World) welches bei weitem keine 4096 Bytes an MSIL Code enthält wird also der Platz aufgefüllt. Änderst Du eine kleinigkeit dran (z.b. ein zweiter WriteLine aufruf) dann hast Du zwar mehr MSIL Code, allerdings immer noch keine 4096 Bytes.
Die Differenz zwischen den 4096 Bytes und der Dateigrösse von 5132 entsteht dadurch dass es mit der Assembly noch lange nicht getan ist und noch zusätzliche Informationen (z.B. PE Header, Metainformationen, etc.) für ein Executable benötigt werden.
Man kann die Boundary Grenzen auch verstellen (Project Properties->Build->Advanced). Minimum ist 512 Byte (ist auch z.b. beim VBC Compiler default)
Grüsse,
Egon
/edit: Zahl 0 gegen NULL getauscht zwecks besserem Verständnis.
Lego Mindstorms NXT
- damit kannst Du so gut wie alles bauen was das Herz begehrt und es gibt eine unzahl von Sensoren von Drittanbietern.
Grüsse,Egon
Hallo,
Visual Paradigm kann ich nur empfehlen - gibts eine Community Edition davon die für die private Benutzung frei ist (hat halt nicht den kompletten Umfang der "großen" Versionen).
Kann auch Standalone betrieben werden (ohne IDE Integration)
Grüsse,
Egon
Hallo,
als Teilprojekt meines aktuellen Projekts (Bewegungsanalyse) ist Video4Mono hervorgegangen. Es handelt sich dabei um ein Interface für Video4Linux mit welchem Daten von Kameras unter Mono genutzt werden können.
Es werden keine weiteren Libraries benötigt, da mittels P/Invoke direkt die entsprechenden Kernel-Routinen benutzt werden.
Zur zeit stehen folgende Funktionalitäten zur Verfügung:* Unterstützung für Video4Linux Version 1 (Da ich keine v4l2 kompatible Webcam habe)
- Unterstützung für die Eingangsformate YUV420 und RGB24 (Danke an Herbivore für die korrekte Formel für YUV420 umrechnung)
- Auslesen der Eigenschaften der Kamera (Auflösung, etc.)
- Einfach zu benutzendes Interface (Auflösung wählen, Eingangsformat wählen, Event subscriben und Daten als Gdk.Pixbuf erhalten)
Es handelt sich zur Zeit um eine Beta-Version die noch nicht den gesamten Funktionsumfang unterstützt. Geplant sind noch:* Unterstützung für andere Low-Level API's damit der Wrapper auch unter Win32 und OSX verwendet werden kann
- Wesentliche erhöhung der Performance (Framerate) bei höheren Auflösungen
Anbei ein Screenshot, der Quellcode befindet sich um nachfolgenden Post.
Grüsse,
Egon
Hallo Herbivore,
danke für deine Antwort - und der Info über die Umrechnung von YUV nach RGB. Die von mir benutzte Formel war falsch, dementsprechend hab ich eine verfälschte Grafik rausbekommen - und da nutzt dann natürlich das mehrfache überprüfen des Algorithmusses nichts wenns schon an der Basis scheitert.
Mit der von Dir angegebenen hauts jetzt prima hin!
Grüsse,
Egon
/edit: Wegen des "unprofessionellen" Posts von mir: Ich glaub ich sollte schlafen gehn, bin schon seit knapp 20 Stunden in der Firma.
Hallo,
sorry dachte ich habe meine Frage so formuliert dass man weiss was ich will: Ich möchte ein byte array welches Daten im YUV420 Format enthält in eines umkonvertieren welches RGB Daten enthält. Weiss aber beim besten willen nicht wie ich die konvertierung anstellen soll - entweder weil meine Gehirnkapazität dafür nicht reicht, oder weil ich mich heute schon zu festgefahren habe bei den von mir angestellten versuchen.
Die angefügten Links enthalten die Dokumentation wie das YUV420 aufgebaut ist, trotzdem bring ichs nicht hin.
Grüsse,
egon
Hallo,
ich muss ein Byte Array welches Daten im YUV420 Format enthält in ein RGB24 (Pro Pixel jeweils ein Byte für R, G und B ) Format umwandeln.
Habe zwar die entsprechenden Dokumentationen gefunden, steh aber trotzdem vollkommen neben mir.
Hat jemand so etwas schon gemacht und kann mir einen Tipp geben bzw. hat schon fertigen Code dafür den er teilen kann?
Danke und Grüsse,
Egon
Referenzen:
YUV420 Format, Link 1
YUV420 Format, Link 2
Original von frisch
@egrath: Ist das Ubuntu oder nur ein Ubuntu-Skin? Falls ersteres, wie programmierst du darauf c# Progs?
Hallo frisch,
es ist Ubuntu (7.10). Als IDE verwende ich MonoDevelop. Mittels VMWare habe ich noch eine kleine Windows Installation im Hintergrund laufen und starte in dieser die MSDN Library (da ich die Onlineversion nicht mag). Damit diese als eigenes Fenster läuft, verbinde ich mich mittels SeamlessRDP auf diese und starte die MSDN Library.
Obige Lösung ist aber auch nur temporär, da sich die Mono Dokumentation mit grossen Schritten weiterentwickelt und es nur mehr eine Frage der Zeit ist bis diese auf dem gleichen Informationsstand ist wie MSDN.
Grüsse,
Egon
Hallo,
wenn schon alle Ihre Screenies posten, dann schliess ich mich nach langem auch mal an damit:
Grüsse,
Egon
Hallo,
ich bin gerade auf ein Tool gestossen von dem ich so dermassen begeister bin dass ich diese Begeisterung mit euch teilen möchte.
Ihr kennt sicherlich folgendes Problem: Man hat mehrere Rechner im Büro stehen (z.b. Notebook und Stand-PC) und zwei Tastaturen und Mäuse. Sicherlich könnte man nun einen KVM Switch nehmen um beide Rechner bedienen zu können, aber erstens ist dies nicht so elegant wie man sich es wünscht und zweitens kostet es etwas.
Abhilfe schafft hier das Tool "Synergy" (Link). Auf jeder beteiligten Maschine wird dabei ein kleiner Daemon (oder Tray-App im Windows fall) gestartet. Es gibt dabei einen Primary Screen (der von dem die Tastatur und Maus benutzt wird) und Secondary Screens, die diese benutzen. Fährt man nun mit der Maus beispielsweise an den rechten Bildschirmrand, so verschwindet die Maus vom Bildschirm und taucht am konfigurierten Secondary wieder auf - und man arbeitet dort weiter. Das alles ist frei konfigurierbar so wie man es sich vorstellt und: läuft unter Windows, Unices und OSX.
Einfach genial das Teil!
Grüsse,
Egon
Hallo,
Wenn es sich um eine GUI Applikation handelt, könntest Du dir den Window Handle raussuchen und anschliessend alle Window Messages mitschneiden. Ist z.b. ein WM_CLOSE für den entsprechenden Handle dabei so soll das Programm geschlossen werden. Anschliessend noch überprüfen ob die Process ID noch existiert und gut ist.
Soweit die Theorie, probiert hab ich obiges noch nicht.
Grüsse,
Egon
Hallo,
.wixpro sind meines Wissens nach Files für den Wise Installer.
Grüsse,
Egon
Hallo,
das Problem welches Du hier bemängelst ist eines jener, welches schon seit anbeginn der öffentlichen CTP's von WPF in den Microsoft Foren bemängelt wurde. WPF benutzt eine eigene ClearType Rendering Engine, welche nicht so "gut" ist wie die mit der das Betriebssystem selbst seine schriften rendert.
Leider gibt es auch keine möglichkeit das abzuschalten, die üblichen Varianten funktionieren bei dieser Engine nicht.
Grüsse,
Egon
Hallo,
für die Pfadsuche kannst Du in späterer folge denn beispielsweise den Breadth-First Algorithmus benutzen (A*Star wäre auch eine möglichkeit, nur ist der komplexer). Ich hab vor einiger Zeit mal was darüber geschrieben:
Grüsse,
Egon
Hallo,
das Buch ist ganz gut, ich habs mir vor einiger Zeit zugelegt - allerdings als E-Book welches man beim Publisher (www.apress.com) kaufen kann. Ist etwas günstiger als die Print Variante.
Grüsse,
Egon
Hallo Orothred,
so zum beispiel:
private void CompareArray<T>( T[] arr1, T[] arr2 )
{
if( arr1.Length != arr2.Length )
{
Console.Out.WriteLine( "Array Length does not match" );
return;
}
for( int index = 0; index < arr1.Length; index ++ )
{
if( ! arr1[index].Equals( arr2[index] ))
{
Console.Out.WriteLine( "Item difference at index: {0}", index );
}
}
}
Grüsse,
Egon
Original von Hajoseb
War das nicht so, dass die Express-Edition immer nur einen Prozessoer (und auch Core???) benutzt ???Mfg hajoseb
Hallo,
in .NET entwickelte Programme werden immer von der CLR ausgeführt und dieser ist es relativ egal mit welcher Entwicklungsumgebung deine Applikation erstellt wurde.
Grüsse,
Egon
Hallo,
ich habs jetzt nicht probiert (da ich keine Domain daheim hab 😉, aber müsste es nicht mit dem "-zone" Parameter (Intranet) gehen?
Grüsse,
Egon
Hallo tscherno,
... so abwegig würde ich das gar nicht finden. Da es mittlerweile auch von Java eine Echtzeitversion gibt, wird dies sicherlich auch früher oder später in .NET (vielleicht nicht von MS sondern beispielsweise in Form von Mono) einzug halten. Und dann steht dem nichts mehr im Weg.
Grüsse,
Egon
... und der Source (MonoDevelop Projekt; inkl Binarys)
Hallo,
ich habe eine kleine Library entwickelt, mit hilfe derer sich Daten von einem XSens MTX AHRS Sensor lesen lassen (1). Dabei wird nicht auf die vom Hersteller im SDK enthaltene Library zurückgegriffen, sondern das gesamte serielle Kommunikationsprotokoll neu und native in .NET geschrieben. Zur Zeit können folgende Daten gelesen und verarbeitet werden:* Orientierungsdaten in Euler Winkeln (2)
- Beschleunigung in X, Y, Z in meter/s²
- Rotationsrate in X, Y, Z in Grad
- Magnetfeld in X, Y, Z in Mega-Gauss
Als Beispiel zur Benutzung liegt eine kleine Demo bei, welche alle Daten in einer simplen Konsolen-GUI ausgibt.
Anbei ein Screenshot.
Grüsse,
Egon
/Referenzen:
(1) AHRS = Attitude and Heading Reference System
(2) Eulersche Winkel
Original von herbivore
Threads würde ich hier nicht verwenden (gibt nur Problem mit dem Zugriff auf die Controls) sondern einen Timer.
Hallo Herbivore,
ich würde eventuell arbeitsintensive Dinge aus gründen der Responsibility der Applikation nicht im Main-Loop machen lassen. Der Zugriff von Threads auf GUI Controls ist doch eh kein Problem (InvokeRequired/BeginInvoke)
Grüsse,
Egon
Hallo,
für jedes neue Bild ein eigenes Image Objekt erstellen und von den (maximal) zwei Bildern die gleichzeitig dargestellt werden sollen jeweils den entsprechenden Bildausschnitt reinkopieren. Dieses Image Objekt dann in der Picturebox darstellen lassen.
Da Du das ganze vermutlich als Animation ausführen willst, das ganze in einem eigenen Thread machen und einen vernünftigen Bildwechsel-Intervall und verschiebung wählen (≥25 Frames/sec)
Grüsse,
Egon
Original von Devilzimti
Ich möchte sowas wie SFX machen
Ne Art ZIP Archiv, dass sich selber entpackt,
über Ressourcen ^^
Hallo,
es gibt so etwas in der Art (komprimierte .NET Assemblys welche sich zur laufzeit selbst entpacken): http://madebits.com/netz/
Der Sourcecode für das Ding ist auch frei, also denk ich mir dass Du dir da sicherlich einiges abschauen könntest.
Grüsse,
Egon
Hallo,
im Prinzip ist es relativ egal welches Linux Du benutzt um damit unter Mono zu entwickeln. Üblicherweise kompiliert man sich als Entwickler ohnehin seine eigene Mono Version inkl. der zugehörigen Abhängigkeiten, da die Packages für Mono bei den meisten Distributionen etwas hinterherhinken - auch bei der Herstellereigenen Distribution OpenSUSE.
Ich handhabe das überlicherweise so, dass ich die bei der Distribution mitinstallierte Mono Version komplett unangetastet lasse und mir eine eigens kompilierte beispielsweise nach /usr/local/mono installiere. Damit hast Du den Vorteil dass du einerseits immer eine aktuelle Mono Umgebung zur Verfügung hast und zweitens nicht die ganzen Abhängigkeiten aktueller Distributionen hin zu mono brichst.
Persönlich würde ich dir Ubuntu empfehlen und zwar aus folgenden Gründen:* Das Package Management System (APT) ist wesentlich ausgreifter als die Lösungen anderer Distributionen (z.b. auf RPM basierende System).
- Ein Distributionsupgrade funktioniert dank Punkt 1 genauso wie er sollte. Es gibt beispielsweise Debian Systeme (auch APT) welche wir mit Version 2.2 installiert haben und ohne neu aufsetzen mittlerweile auf Version 4.0 sind.
Letztenendes ist es aber wie überall persönlicher Geschmack der entscheidet.
Grüsse,
Egon
Hallo,
eventuell wären Lego Mindstorms NXT was für dich. Kann beispielsweise mit dem Microsoft Robotics Studio programmiert werden. Ich hab mich einige Zeit lang mit den Teilen beschäftigt und war begeistert davon (hab allerdings kein Robotics Studio genommen, sondern die Teile in Java programmiert)
Grüsse,
Egon
/edit: Und ach ja, es gibt von Drittherstellern extrem edle Sensoren für die Tele (Infrarot-Wärmeerkennung, etc.)
Original von Golo
Original von egrath
zu deiner Aussage muss ich dir wiedersprechen. Es ist vollkommen egal, siehe untenstehenden Code:Doch, es macht einen Unterschied. Und zwar wird es vom JIT-Compiler (!) zur Laufzeit anders gehandhabt ... siehe Compilerflag BEFOREFIELDINIT.
Hallo Golo,
Danke für die Info, auf eine andere Handhabung seitens des JIT Compilers wär ich beim besten Willen nicht gekommen. Nach etwas Googlen bin ich auf folgenden Interessanten Link gestossen der die Sache relativ schön erklärt:
... für alle die es interessiert.
Grüsse,
Egon
Hallo Golo,
zu deiner Aussage muss ich dir wiedersprechen. Es ist vollkommen egal, siehe untenstehenden Code:
Ursprungscode:
using System;
public class Test
{
public static int a = 32;
public static int b;
public int c = 96;
public int d;
static Test()
{
b = 64;
}
public Test()
{
d = 128;
}
public static void Main( string[] args )
{
new Test();
}
}
Disassemblat:
.assembly extern mscorlib
{
.ver 2:0:0:0
.publickeytoken = (B7 7A 5C 56 19 34 E0 89 ) // .z\V.4..
}
.assembly 'test'
{
.custom instance void class [mscorlib]System.Runtime.CompilerServices.CompilationRelaxationsAttribute::.ctor(int32) = (01 00 08 00 00 00 00 00 ) // ........
.custom instance void class [mscorlib]System.Runtime.CompilerServices.RuntimeCompatibilityAttribute::.ctor() = (
01 00 01 00 54 02 16 57 72 61 70 4E 6F 6E 45 78 // ....T..WrapNonEx
63 65 70 74 69 6F 6E 54 68 72 6F 77 73 01 ) // ceptionThrows.
.hash algorithm 0x00008004
.ver 0:0:0:0
}
.module test.exe // GUID = {91C00F1C-17F0-4486-9959-7CD5D33CE823}
.class public auto ansi Test
extends [mscorlib]System.Object
{
.field public static int32 a
.field public static int32 b
.field public int32 c
.field public int32 d
// method line 1
.method private static hidebysig specialname rtspecialname
default void .cctor () cil managed
{
// Method begins at RVA 0x2050
// Code size 17 (0x11)
.maxstack 8
IL_0000: ldc.i4.s 0x20
IL_0002: stsfld int32 Test::a
IL_0007: nop
IL_0008: ldc.i4.s 0x40
IL_000a: stsfld int32 Test::b
IL_000f: nop
IL_0010: ret
} // end of method Test::.cctor
// method line 2
.method public hidebysig specialname rtspecialname
instance default void .ctor () cil managed
{
// Method begins at RVA 0x2062
// Code size 29 (0x1d)
.maxstack 8
IL_0000: ldarg.0
IL_0001: ldc.i4.s 0x60
IL_0003: stfld int32 Test::c
IL_0008: ldarg.0
IL_0009: call instance void object::.ctor()
IL_000e: nop
IL_000f: nop
IL_0010: ldarg.0
IL_0011: ldc.i4 128
IL_0016: stfld int32 Test::d
IL_001b: nop
IL_001c: ret
} // end of method Test::.ctor
// method line 3
.method public static hidebysig
default void Main (string[] args) cil managed
{
// Method begins at RVA 0x2080
.entrypoint
// Code size 8 (0x8)
.maxstack 8
IL_0000: nop
IL_0001: newobj instance void class Test::.ctor()
IL_0006: pop
IL_0007: ret
} // end of method Test::Main
} // end of class Test
Wie man sehen kann wird im statischen Konstruktor zuerst die Variable "a" initialisiert, dann kommt ein No-Op und dann die Variable "b", welche ich tatsächlich programmatisch im Konstruktor initialisiere.
Grüsse,
Egon
Hallo,
für Windows gibts in dem Bereich WSE (in Version 2.0 und 3.0) welche diese Funktionalität über SoapReceivers zur Verfügung stellen. Für Mono funktioniert das ganze leider auch nicht, da aufgrund von diversen Problemen ein Port fallen gelassen wurde.
Werde mich also selber dran machen so etwas einfach zu stricken und das ganze dann als Projekt zur verfügung zu stellen.
Grüsse,
Egon
Hallo,
Wenn Du nur über andere .NET Anwendungen auf deine Applikation zugreifen willst, könnte Remoting das mittel deiner Wahl sein. Sollte es platformunabhängig sein, so verwende ein vorgeschaltetes Webservice welches dann mittels Remoting mit deiner Applikation kommuniziert.
Grüsse,
Egon
Hallo,
eventuell so was wie:
if( System.Array.IndexOf( meinArray, dasObjektWelchesEingefügtWerdenSoll ) != -1 )
// insert
}
Grüsse,
Egon
Hallo langalaxy,
WCF wäre natürlich eine Möglichkeit - kommt jedoch für mich als Mono Framework Nutzer leider (noch) nicht in Frage.
Grüsse,
Egon
Hallo wakestar,
danke für den Link, den kannte ich schon und beschreibt in groben Zügen auch in die Richtung was ich machen möchte - nur halt dass ich keine asmx Dateien aus dem Filesystem ausführen möchte, sondern eben Methoden welche in der ausführenden Assembly mit dem WebMethod Attribut versehen sind.
Grüsse,
Egon
/edit: Ich werf hier auch noch mal nen Link ins rennen, der ähnliches vollbringt wie der vom Vorposter: Klick
Hallo,
ich bin gerade dabei, darüber nachzudenken wie ich eine bestehende Serverapplikation am besten über WebServices nutzbar mache. Dabei könnte folgende, klassische Architektur in frage kommen:
+--------+ +---------+ +-------------+
| Client | <=SOAP over HTTP=> | ASMX | <=REMOTING=> | Application |
+--------+ | on IIS | +-------------+
+---------+
Dabei gefällt mir allerdings nicht, dass ich einen Extra IIS (oder anderen .NET fähigen Webserver) benötige und dann mittels eines anderen Mechanismusses wieder mit der Applikation kommunizieren muss.
Der nächste Schritt meiner Überlegung wäre es nun, einen eigenen HttpListener in die Applikation zu integrieren welcher die SOAP Anfragen entgegennimmt, verarbeitet und das Ergebnis zurücksendet:
+--------+ +--------------|---+
| Client | <=SOAP over HTTP=> | Embedded WS | |
+--------+ | Provider | |
---------------+ |
| Application |
+------------------+
Bei dieser Methodik muss ich mich aber nach meinem Wissensstand mit den ganzen Details von SOAP selbst rumschlagen - oder? Gibt es in diesem Bereich etwas fertiges auf das ich zurückgreifen kann oder bin ich auf mich alleine gestellt und muss das ganze Zeug implementieren und dann der Community zur verfügung stellen damit sich nicht wenigstens andere Leute mehr mit dem Gewerkel rumärgen müssen 😉 ?
Grüsse,
Egon
Hallo,
es kommt immer darauf an, auf welcher Systemplatform man sich befindet - auf x86 Systemen welche auf Intel Technologie fussen ist es relativ egal auf welchem Kern ein Thread läuft, da alle Prozessoren auf den gleichen Arbeitsspeicher über einen gemeinsamen Frontside Bus zugreifen.
Anders sieht die Sache aus, wenn man eine SMP NUMA System hat, wie beispielsweise einen Dual Opteron. Bei diesem hat jede CPU einen lokalen Speicher, der Zugriff auf den nicht-lokalen geschieht dann über eine andere CPU. Auf so einem System ist es sinnvoll, einen Thread auf einer CPU zu halten damit Speicherzugriffe nicht über die CPU Interlink's gehen.
Grüsse,
Egon