Danke für deine Antwort. Was spricht gegen den Einsatz von Tooltips?

Hallo,

das GUI meiner Anwendung wurde mit WPF und dem Caliburn.Micro Framework entwickelt. Die Hilfe innerhalb der Anwendung soll kontextsensitiv gestaltet werden. Es gibt einen globalen Button in einer Art Ribbon Bar, der, bei Betätigen, die Hilfe aufruft. Neben den Controls sollen Texte erscheinen, die deren Funktionalität erklären. Es sollen in einem View, das gerade aktiv ist, alle Texte gleichzeitig erscheinen und auch gleichzeitig wieder ausgeblendet werden. Bei Verschieben des Hauptfensters sollen sich die Container der Texte gleichermaßen mit verschieben. Bei aktiver Hilfe soll das aktuelle View leicht verschwommen im Hintergrund dargestellt werden, die Texte und deren Container on top, natürlich nicht verschwommen.

Die Anforderungen stehen also, nur ist die Wahl der Technologie noch nicht klar. Wie würdet ihr das machen? Die Idee ist, die Tooltips der Controls zu verwenden und entsprechend zu verwalten. Ist das mit den Anforderungen vereinbar? Welche Alternative Technologien gibt es? Allgemein mit AdornedControls?

Danke und Grüße,
gm

Hallo t0ms3n,

in der Tat! Das Problem lag/liegt woanders. Ich bin der Sache auch bereits auf der Spur...

Grüße, Marc

Hallo Scavanger,

ich habe natürlich zuvor gegoogelt und herausgefunden, dass man [Flags] setzen muss, wenn man mit Kombinationen arbeitet. Leider hilft das nicht beim Deserialisieren.

Grüße, Marc

Hallo Spook,

ich erhalte mit

    [FlagsAttribute]
    [Serializable]
    public enum WeekDays
    {
        [XmlEnum("1")]
        Sunday = 1,
        [XmlEnum("2")]
        Monday = 2,
        [XmlEnum("4")]
        Tuesday = 4,
        [XmlEnum("8")]
        Wednesday = 8,
        [XmlEnum("16")]
        Thursday = 16,
        [XmlEnum("32")]
        Friday = 32,
        [XmlEnum("64")]
        Saturday = 64,
        [XmlEnum("65")]
        WeekendDays = Sunday | Saturday,
        [XmlEnum("62")]
        WorkDays = Monday | Tuesday | Wednesday | Thursday | Friday,
        [XmlEnum("127")]
        EveryDay = WeekendDays | WorkDays
    }

die gleiche Fehlermeldung: "{"Instanzvalidierungsfehler: '10' ist kein gültiger Wert für global::RecurrenceLibary.WeekDays."}"

[Flags]

habe ich auch bereits versucht.

Danke und Grüße, Marc

Hallo,

ich verwende folgendes Enum innerhalb eines Objektes, dass ich deserialisieren möchte. Das klappt soweit prima.

    [Serializable]
    public enum WeekDays
    {
        [XmlEnum("1")]
        Sunday = 1,
        [XmlEnum("2")]
        Monday = 2,
        [XmlEnum("4")]
        Tuesday = 4,
        [XmlEnum("8")]
        Wednesday = 8,
        [XmlEnum("16")]
        Thursday = 16,
        [XmlEnum("32")]
        Friday = 32,
        [XmlEnum("64")]
        Saturday = 64,
        [XmlEnum("65")]
        WeekendDays = Sunday | Saturday,
        [XmlEnum("62")]
        WorkDays = Monday | Tuesday | Wednesday | Thursday | Friday,
        [XmlEnum("127")]
        EveryDay = WeekendDays | WorkDays
    }

Nun ergibt sich aber die Problematik, dass ich Kombinationen derart ( Monday | Wednesday o.ä.) deserialisieren möchte. Ich erhalte eine Exception, dass der Wert nicht vorhanden ist.
Ich möchte natürlich unbedingt verhindern, dass ich alle Kombinationen explizit definieren muss. Wie kann ich das umgehen?

Danke und Grüße,
Marc

So ich habe es jetzt hinbekommen:

object obj;
using (XmlReader reader = XmlReader.Create(new StringReader(recurrenceInfo)))
{
    reader.MoveToContent();
    switch (reader.Name)
    {
        case "RecurrenceInfo":
            obj = new XmlSerializer(typeof(RecurrenceLibary.RecurrenceInfo)).Deserialize(reader);
            break;
        default:
            throw new NotSupportedException("Unexpected: " + reader.Name);
    }
}

Danke, unconnected für deine Tipps!

Hallo,

danke für deine Antwort. Ich habe das gleich ausprobiert! Das Problem vor dem ich nun stehe, ist, dass die Information als ein String vorliegt. Wie kann ich dem Serializer das "beibringen"?

Grüße, Marc

verwendetes Datenbanksystem: <SQL 2008>

Hallo,

ich habe folgenden XML-String:

<RecurrenceInfo Start="02/07/2013 00:00:00" End="02/07/2013 00:00:00" Id="8169acc8-7280-41f6-a58e-288cd6d66ce6" />

Ich möchte gerne daraus ein Objekt vom Typ RecurrenceInfo erzeugen, allerdings komme ich mit dem Format nicht klar. Wie kann ich da vorgehen?

Muss/ kann ich mit XmlDocument arbeiten?

Grüße und Danke, Marc

Hallo,

ich möchte ein Array der Größe n ab einschließlich dem Index 1 (Position 2) mit einem Array der Größe n-2 überschreiben. Wie geht das ohne eine Schleife?

Danke und Grüße, gm

Danke für deine Antwort. Ich habe das hier entdeckt: http://w3studi.informatik.uni-stuttgart.de/~bischowg/languages/CSharp/CSRemoting.html

Gibt es denn eine Möglichkeit ohne die ThirdParty Bibliothek IIOP?

Edit: IIOP .NET Project: http://sourceforge.net/projects/iiop-net/

Hallo,

wie gestalte ich die Kommunikation zwischen zwei .NET Anwendungen A und B? Es geht um Datenaustausch und Steuerung der Anwendung B durch die Anwendung A über ein Netzwerk.
Eine Datenbank spielt dabei erstmal keine Rolle? Wäre WCF Data Services etwas für mich? Was ich dazu bisher recherchiert habe, überzeugt mich allerdings nicht.

Besten Dank und Grüße
gaussmath

Der Thread ist wirklich sehr interessant. Ich habe mich auch mit der Thematik beschäftigt, und ich werde letztlich die Vorteile beider Sprachen verwenden, indem ich zeitkritische Berechnungen auslagere und damit Fortran-DLLs "beauftrage".

Erste Tests haben gezeigt, dass die Performancevorteile sehr groß sind. Nachteil: Man muss einen teuren Compiler kaufen...

Vielen Dank für eure Antworten! Die Vorschläge sind hilfreich. 😃

Hallo,

wie kann ich komfortabel die ersten n Nachkommastellen ermitteln, ohne (explizit) auf integer casten zu müssen?

Grüße, Marc

Auch das Problem mit der DLL hat sich erledigt!

Ja, natürlich befinden sich EXE und DLL im selben Ordner. Ich vermute, dass es daran liegt, dass ich eine Demoversion verwende und die Software daher systemgebunden ist.

Edit: An der Demoversion liegt es auch nicht. Eine Test-EXE läuft auch auf anderen Systemen.

Hallo herbivore!

Danke für deine Antwort! Das Ausgangsproblem habe ich gelöst. Allerdings stellt sich nun das Problem, dass meine DLL nicht gefunden werden kann, wenn ich die Exe und DLL auf einem anderen System teste. Ich habe den Pfad relativ angeben. Auf meinem System läuft das auch prima.

Grüße, gaussmath

Hallo,

falls jemand den Intel Fortran Compiler als Integration ins MS Visual Studio verwendet:

Ich versuche über "use" die LAPACK Bibliothek einzubinden und erhalte den Fehler, dass der externe Verweis nicht aufgelöst werden kann.

Was kann ich tun? Googlen hat mich nicht wirklich schlauer gemacht.

Grüße, gaussmath

Ja, ihr habt recht, es muss am Compiler liegen. Jetzt heißt es, die Optionen zu checken...

Edit: In der Tat, es lag an den Compilereinstellungen!!! Damit hat sich das Thema erledigt. Ich bedanke mich für die rege Beteiligung. 😃

Hallo herbivore,

ich fühle mich ein wenig gescholten, aber nichts für ungut...

So einfach und klar ist die Sache nicht, weil

1. ich die Fortran.exe und Fortran-DLL (so wie ich sie in der C#-Anwendung aufrufe) unter denselben Bedingungen bzw. mit denselben Einstellungen kompiliert habe.

2. ich die DLL so konzipiert habe, dass diese nur EINMAL aufgerufen wird, so dass Overhead durch zu häufige Aufrufe ausgeschlossen werden kann. Der Subroutine "permut" wird indes mit O(n!) sehr häufig aufgerufen, das allerdings innerhalb des nativen Codes. Wie ich gemessen habe, wird doch aus meinen Codebeispielen heraus klar.

Mir ist unterm Strich noch überhaupt nicht klar, woher diese Laufzeitunterschiede kommen.

Grüße, gaussmath

Welche Sprünge sollen das sein? Hat jemand vielleicht irgendwelche Referenzen von Microsoft selbst, wo ich etwas über den Performanceverlust beim Aufrufen von nativem Code nachlesen kann?

Was bedeutet dann, dass P-Invokes gejittet werden?

nein, der kompilierte Fortram-Code wird nicht nochmal übersetzt. Sonst würden ja auch Systemaufrufe (z.B. für Windows-Messages, Paint-Aufforderung etc.) immer decompiliert.

Gut, aber warum läuft die FORTAN-DLL dann so viel langsamer?

Der native code läuft nicht langsamer.

Wird da nicht grundsätzlich noch der Fortran-Maschinencode in MSIL übersetzt, die dann wiederum gejittet wird?!

Auch pinvokes werden gejittet. Hast du den ersten aufruf mit dem zweiten verglichen?

Eine etwas späte Reaktion auf diesen Beitrag. Wieso P-Invoke? Ich verwende doch "using System.Runtime.InteropServices;", also COM Interop?!

EDIT: Diese Frage hat sich erledigt!

Also gut, ich werde höchstwahrscheinlich reinen Fortran-Code schreiben. Dann muss man eben die Schnittstelle zur Hauptanwendung an einer anderen Stelle geschaffen werden.

Aber noch einmal die konkrete Frage: Warum genau läuft der native Code langsamer, wenn eine .NET-Anwendung diese Bibliothek aufruft?

Danke nochmal für eure Antworten. F# wäre eine Alternative. Da dies aber ebenfalls auf dem CLR-Konzept aufsetzt, sehe ich da keine Performancevorteile.

@Siassei: Meine Anwendung ist extrem zeitkritisch. Das ist eine wichtige a priori Erkenntnis. Daher versuche ich Berechnungen auszulagern, um die Laufzeit zu optimieren.

Es sei aber nochmal betont, dass C# auch auf mein Beispiel bezogen nicht schneller ist. Programmiere ich eine reine FORTRAN-Anwendung, ist diese mit derselben DLL rund zweimal schneller. Der Flaschenhals entsteht beim Aufrufen der DLL innerhalb der C#-Anwendung.

Hier einmal der C#-Code zum Aufrufen der DLL:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Runtime.InteropServices;
using CSharpDllTest;

namespace FortranDllCallTest
{

    class Program
    {
        static void Main(string[] args)
        {
            int[] arr = {1,2,3,4,5,6,7,8,9,10,11};

            int arraySize = arr.Length;


            //************Aufruf der CSharp DLL****************

            PERMUTATIONUD csharpdll = new PERMUTATIONUD();
            csharpdll.PERMUTATIONUDMAIN(arr, arr.Length);

            //************Aufruf der Fortan DLL****************

            FortranDllWrap.FPERMUTATIONUD(arr, ref arraySize);
            //FortranDllWrap.FPERMUTATIONUD();


            Console.ReadKey();
        }

    }

    public class FortranDllWrap
    {

        // CallingConvention.Cdecl must be used since the stack is

        // cleaned up by the caller in Intel Fortran by default

        [DllImport("D:/Algorithmen/Fortran/Testcode/DllTest/DllTest/Debug/DllTest.dll", CallingConvention = CallingConvention.Cdecl)]
        public static extern void FPERMUTATIONUD(int[] arr, ref int arraySize);

        //public static extern void FPERMUTATIONUD();
 
    }

}

OK, ich formuliere einmal meine Zielstellung. Ich programmiere ein Planungstool in C#. Zu Optimierungszwecken möchte ich (numerische) Berechnungen nach Fortran-DLLen auslagern. Denn, kurzum, möchte man Rechnen und gigantische numerische Objekte "wälzen" ist Fortran schneller.

Die Frage ist nun, wie ich das praktisch umsetzen kann. Ich habe also eine kleine Beispiel-DLL in Fortran erstellt und rufe diese aus meiner C#-Anwendung heraus auf. Jetzt muss ich aber feststellen, dass das ganze dann langsamer wird.

Rufe ich dieselbe DLL aus einer Fortran-Anwendung heraus auf, benötigt der Durchlauf für n=11 1,2 Sekunden, aus C# heraus jedoch 5 Sekunden.

Woran liegt das? Ist es ein zusätzlicher Verwaltungsaufwand des .NET Frameworks? Wenn ja, was kann ich optimieren?

Die Hauptfrage ist aber, lohnt sich das Auslagern nach Fortran-Bibliotheken überhaupt? Mein bisherigen Versuche haben gezeigt, dass dies nicht der Fall ist.

Ja, habe ich getan. C# schneidet immer besser ab. Nach dem zweiten, dritten Durchlauf sogar noch besser.

Hast du den ersten aufruf mit dem zweiten verglichen?

Wie meinst du das?

Wenn ich übrigens eine reine Fortrananwendung erstelle und die DLL nicht in einer .NET-Anwendung aufrufe, ist der Performance deutlich schneller. Ungefähr 3 Mal so schnell wie der C#-Code.

Warum ist das so? Entsteht durch das Aufrufen der Fortran-DLL innerhalb der .NET-Anwendung ein höherer Speicherverwaltungsaufwand?

Edit: Welche Compiler-Flags hast du beim Fortran-Compiler gesetzt? Debug, Release, Performance?

Hi!

Ich verwende die Integration des Intel Fortran Compilers ins VS. Wie stellt man das dort ein?

Danke für die Antwort. Bei diesem Code verhält es sich allerdings genau anders herum! Fortran ist langsamer als C#. Deswegen habe ich diesen Thread erstellt, weil mich dieser Sachverhalt doch sehr verwundert.

Warum ist dieser Fortran-Code (kompiliert mit den aktuellsten Intel Fortran Compiler, 32 bit)

Subroutine PERMUTATIONUD(PArray, SizePArray)
!DEC$ ATTRIBUTES DLLEXPORT :: PERMUTATIONUD
    implicit none
    integer :: SizePArray
    integer, dimension(SizePArray) :: PArray
    real :: T1, T2

    CALL CPU_TIME(T1)

    call PERMUT(PArray, SizePArray, SizePArray)
    CALL CPU_TIME(T2)

    write( *, * ) T2-T1


End Subroutine PERMUTATIONUD


Subroutine SWAPUD(PArray, FirstIndex, SecondIndex, SizePArray)

    implicit none
    integer :: FirstIndex, SecondIndex,SizePArray
    integer, dimension(SizePArray) :: PArray
    integer :: tmp

    tmp = PArray(FirstIndex)
    PArray(FirstIndex) = PArray(SecondIndex)
    PArray(SecondIndex) = tmp

End Subroutine SWAPUD
 
recursive Subroutine PERMUT(PArray, EndIndex, SizePArray)

    implicit none
    integer :: EndIndex, SizePArray,i
    integer, dimension(SizePArray) :: PArray

    if( EndIndex == 1 ) then
    !write( *, * ) PArray
    i=1

    else
    call PERMUT(PArray,EndIndex-1,SizePArray )

    do i = 1, EndIndex-1
    call SWAPUD(PArray,i,EndIndex,SizePArray)
    call PERMUT(PArray,EndIndex-1,SizePArray)
    call SWAPUD(PArray,i,EndIndex,SizePArray)
    end do

    end if

End Subroutine PERMUT

langsamer als dieser (kompiliert mit VS 2010, 32 bit)?

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Diagnostics;

namespace CSharpDllTest
{
    public class PERMUTATIONUD
    {
        public void PERMUTATIONUDMAIN(int[] arr, int SizeArray)
        {
            Stopwatch sw = new Stopwatch();
            sw.Start();
            permut(arr, SizeArray-1);
            sw.Stop();
            long _milliSeconds = (long)(sw.ElapsedMilliseconds);
            Console.WriteLine(_milliSeconds/1000.0);
           
        }

        private void permut(int[] arr, int EndIndex)
        {
            int i;
            if (EndIndex == 0)
                //PrintMethod(arr);
                i = 1;
            else
            {
                permut(arr, EndIndex - 1);
                for (i = 0; i < EndIndex; i++)
                {
                    this.swap(arr, i, EndIndex);
                    this.permut(arr, EndIndex - 1);
                    this.swap(arr, i, EndIndex);
                }
            }

        }

        private void swap(int[] arr, int FirstIndex, int SecondIndex)
        {
            int tmp = arr[FirstIndex];
            arr[FirstIndex] = arr[SecondIndex];
            arr[SecondIndex] = tmp;
        }

        private void PrintMethod(int[] arr)
        {
            string temp = "";
            foreach (var item in arr)
            {
                temp += item.ToString();
                temp += ", ";

            }
            Console.WriteLine(temp);
        }
    }
}

Die Frage ist jedoch, was bietet Haskell mehr als F#?

Das frage ich mich auch. Angeblich soll es schneller sein als F#. Und das sogar wesentlich.

Danke für die Links!

Hallo Corpsegrinder,

Haskell soll angeblich sehr schnell sein, lässt sich wahrscheinlich aber nicht in eine .NET Umgebung integrieren?!

Grüße, Marc

Die Diagramme am Anfang des Threads von gfoidl zeigen noch Verteilungen der Zahlen, jetzt gegen Ende geht es um die Gleichverteilungen der Kombinationen.

Hi,

das ist doch dasselbe. Jede Kombination ist gleichwahrscheinlich, somit kommt jeder Eintrag des Tripels (Zahl) gleich oft vor.

Grüße, gm

Wenn das wirklich klappt, wäre das eine enorme Optimierung. Ich werde das in den nächsten Tagen mal vollständig implementieren.

Hallo zusammen!

Danke für eure Antworten. Ich habe auf http://www.ctocorner.com/fsharp/book/ ein E-book entdeckt. Das beschreibt F# einigermaßen ausführlich. Sollte sich Parallelisierung damit komfortabel umsetzen lassen, ist die Sprache für mich interessant!

Grüße, gm

Moin zommi,

hast du die Gleichverteilung mal überprüft mit dem Algorithmus? Hast du ein Diagramm?

Grüße, Marc

Hallo herbivore,

ich habe in der Tat Zweifel an meiner Aussage und werde da nochmal drüber nachdenken. Bis dahin werde ich meine bisherigen Beiträge editieren, so dass die Unsicherheit zum Ausdruck kommt.

Grüße, gm

[EDIT]Sind zwei Zufallsvariablen gleichverteilt, so ist auch deren Differenz wahrscheinlich nicht gleichverteilt.[/EDIT] Man könnte eventuell über den zentralen Grenzwertsatz argumentieren, was noch zu prüfen ist.

Nein, das passt schon:

a+b+c=z_1-0+z_2-z_1+100-z_2= z_1-z_1 + z_2-z_2 +100 =100

Mein Werte sind wahrscheinlich gleichverteilt über [0,100]. Dies muss jedoch erst noch bewiesen werden.

Hi!

Kann es sein, dass ihr das ein wenig kompliziert gemacht habt? Mann nimmt einfach zwei Zufallszahlen aus [0,100] dann speichert man diese in ein Array bestehend aus 0,z_1,z_2,100 und rechnet a=z_1-0, b=z_2-z_1, c=100-z_2. Allgemein also z_(i+1)-z_i.

Was man also macht, ist die Summe der Abstände aufsummieren.

Grüße, Marc

Hallo liebe myCSharp Community,

Microsofts neue Programmiersprache F# soll sich hervorragend eignen, um funktionale Zusammenhänge darzustellen. Das heißt also: Diese Sprache ist prädestiniert dafür, mathematische Probleme damit darzustellen und zu lösen.

Hat jemand Erfahrung mit F#? Wie ist die Performance? Wie lässt es sich damit entwickeln?

Gibt es gute Tutoriasl? Wenn ja, wo?

Danke und Grüße, gm