Laden...

Forenbeiträge von Scavanger Ingesamt 309 Beiträge

08.10.2020 - 17:20 Uhr

@MrSparkle:
Ich weiß, es mir nur klar zu machen um was es mir geht.

@Abt:
Super danke, an das Unboxing hab ich nicht gedacht. 👍

07.10.2020 - 21:20 Uhr

Servus,

ich hab eine Verständnis frage:

Ursprünglich wollte ich folgendes machen:


List<uint> l1 = new List<uint> { 1, 2, 3 };
var l2 = l1.Cast<int>().ToList();

Das wirft > Fehlermeldung:

System.InvalidCastException: "Unable to cast object of type 'System.UInt32' to type 'System.Int32'."

Nun ja, das lässt sich ja einfach mit


var l2 = l1.Select(i => (int)i).ToList();

ersetzen, kein Problem.

Aber irgenwie hat mir das keine Ruhe gelassen, IEnumerable<T> Cast<T> ist folgendermaßen implementiert:


public static IEnumerable<T> Cast<T>(this IEnumerable source)
{
    foreach (object o in source)
        yield return (T)o;
}

Das Problem ist, dass der Wert in ein object gesteckt wird, dieser Code wirft die gleiche Exception:


uint i = 42;
object o = i;
int j = (int)o;

Erst dachte ich, Werttypen können nicht aus einem object zurück gecastet werden, aber folgerndes funktioniert:


int i = 42;
object o = i;
int j = (int)o;

Warum können objects, mit einem Werttypen, nicht in einen anderen Werttypen gecastet werden? Vor allem da ja in der Exception die korrekten Typen genannt werden, also warum kann er den Cast nicht ausführen?

30.05.2018 - 16:50 Uhr

Versuche es mal über die Eigenschaft SelectedItem

Bringt ihm nix, SelectedItem wird erst aktualisiert hat nachdem das Item angeklickt wurde.

Ich denke du wirst selbst berechnen müssen über welchen Item der Mauszeiger ist.
Du kannst das MouseMove Event abonieren, in den MouseEventArgs bekommst du die Koordinaten und dann kannst du per DropDownHeight und der Anzahl der Items berechnen über welchen Item der Zeiger sich befindet.

14.05.2018 - 15:15 Uhr

Nein, das geht definitiv nicht.
Max. an die Metatdaten (Name und auf welchem Index sie liegen) kommt man ran. Mir sind ach keine anderen Libs bekannt die das können (mit Mono.Ceici z.B. gehts auch nicht).l

26.03.2018 - 17:59 Uhr

Das Problem mit dem Überlauf besteht weiterhin.
Int32 und int sind, wie schon angemerkt der gleiche Datentyp.

Das Problem lässt sich leider nicht (so einfach) lösen, da die verwendeten Windowsfunktionen nur 32bit Werte als Paramter haben und es keine 64bit Versionen gibt.

15.03.2018 - 10:23 Uhr

Nach ewiger Zeit hab ich mal wieder daran gesetzt und das Projekt an den aktuellen Stand des originals gebracht und endlich werden auch 64bit unterstützt.

Enschränkungen:

  • Nur 32bit oder 64bit möglich (Aufruf aus "MixedMode" (noch) nicht möglich)
  • Kein laden von resourcen aus der nativen DLL
09.03.2018 - 12:00 Uhr

*Klatsch-ans-Hirn* 😁

Danke, damit geht's natürlich easy.
Man sollte doch öfters mal schauen was die neuen Frameworkversionen so bieten. Das Projekt war noch auf dem alten 3.5er, da gab es die generische Version noch nicht.

Ich hab inzwischen einen "nasty Hack" gefunden wie es auch mit den alten Version funktioniert:


public TDelegate GetDelegate<TDelegate>(string foo) where TDelegate : class
{
     // Runtimeprüfung
     return (TDelegate)(object)Marshal.GetDelegateForFunctionPointer( ... );
}

08.03.2018 - 23:19 Uhr

Ich beschäftige mich nach langer Zeit mal wieder mit einem alten Projekt: MemoryModule.net (https://github.com/Scavanger/MemoryModule.net).
Es geht darum eine native DLL aus dem Speicher zu laden, ist ein .net-Port des ursprünglich in C geschriebenen Moduls. (https://github.com/fancycode/MemoryModule)

Also ich bekomme einen Funktionszeiger auf eine native Funktion (der geladenen DLL) und wandle ihn mit Marshal.GetDelegateForFunctionPointer() in einen Delegaten.

Wie gesagt, eine Funktion mit Generics wäre schön, dann wäre die Klasse sehr handlich, der Funktionsaufruf mit dem Cast und typeof wirkt doch recht altbacken.

08.03.2018 - 22:47 Uhr

unconstrained-melody ist schon etwas mit Kanonen auf Spatzen schießen, es geht nur um eine Methode in einem Modul.

Ja danke, der Runtime check geht relativ problemlos mit


if (!typeof(Delegate).IsAssignableFrom(typeof(TDelegate)))
    throw new InvalidOperationException();

aber wie kann ich den Delegaten (ich kann erst hier mit dem konkreten Typ arbeiten, es ist im Endeffekt ein nativer Funktionszeiger, mit Marshal.GetDelegateForFunctionPointer erzeugt) auf den konkreten Typ casten?

08.03.2018 - 17:05 Uhr

Servus zusammen,

bis jetzt hatte ich in einem Projekt eine Methode die einen Delegaten zurückgibt, mir der folgenden Signatur:
Marshal.GetDelegateForFunctionPointer(), funktioniert genau so.


public Delegate GetDelegate(string foo, Type t)
{ 
//...
}

Benutzt wird sie so:


MyDelegate myDelegate = (MyDelegate)obj.GetDelegate("foo", typeof(MyDelegate );

Was ich nicht sehr hübsch finde, der Cast und das typeof() stören mich irgendwie, für so etwas wurden doch Generics erfunden, aber warum kann ich keine Delegaten als Constraints verwenden?
Dadurch kann ich nicht auf den richtigen Typ casten.

Das ist was ich gerne hätte:


public TDelegate GetDelegate<TDelegate>(string foo) where TDelegate : Delegate
{
     return (TDelegate)GetDelegate(foo, typeof(TDelegate));
}

21.02.2017 - 17:24 Uhr

Ich muss mal kurz Frust ablassen:

Kennt das jemand?
Man hat ein neues Projekt und benötigt eine native Bibliothek, freut sich schon mal das es einen .net Wrapper gibt und dann bekommt man sinngemäß sowas serviert:


int err = FancyMethod(int foo, string bar);
if (err != 0)
     // Fehlerbehandlung hier


Nicht zu vergessen das der ganze Wrapper nur aus statischen Methoden besteht.

Warum macht jemand sowas?
Da kann ich gleich die DLL mit DllImport selber laden, mit Objektorientierung hat das doch nix zu tun.
OK, immerhin muss ich mich nicht mit dem ganzen Marshalling herumschlagen, aber trotzdem nervt mich sowas immer wieder.

So jetzt geht's wieder besser. 😁

14.06.2016 - 10:38 Uhr

Hallo,

wie gut kannst du löten?

Ich würde sowas nicht mit dem PC steuern, sondern einen Arduino dafür einspannen. Gibt eine MIDI Lib dafür und ein Relais ist auch schnell angeschlossen.
Für ein Midi-Interface braucht es gerade einmal zwei Widerstände an Arduino.

Zu den MIDI Befehlen, das Stichwort ist MMC (MIDI Machine Control): MIDI Machine Control

14.06.2016 - 10:16 Uhr

Ein Enum ist ein Enum und kein String, umgekehrt wird aber ein Schuh draus:

Enum.ToString-Methode (String)


enum VideoDevices
{
    Webcam,
    Framegrabber,
    Actioncam,

}

//...

string a = VideoDevices.Actioncam.ToString();
string b = VideoDevices.Framegrabber.ToString();
string c = VideoDevices.Webcam.ToString();

21.04.2016 - 23:31 Uhr

Nunja,

wenn es wirklich C**** ist, also Objektorientiert, dann ist es mit einfachem PInvoke (= DLL-Import) nicht getan, da musst du dann mit Implicit PInvoke ran, d.H. du musst erst einen Wrapper in Managed C schreiben.
So ein Wrapper kann allerdings recht aufwendig werden, gerade bei einem großen Toolkit wie dem JT Open Toolkit, wäre so ein Wrapper allein ein recht großes Projekt.

Ich hab so was mal für eine recht kleine Library gemacht, alleine die Konvertierung der X Stringtypen hat mir einige Graue Haare gekostet. 😉

14.12.2015 - 17:20 Uhr

Servus,

danke für euren Input.

In der Regel macht man sowas mit einem eigenen Event, welches vom Aufrufer abonniert wird.

Und wenn man dann ohnehin ein eigenes Event hat - ist es zudem recht intelligent diesem auch ein Property in Form des Objekts, welches der Aufrufer gerne hätte mitzugeben.

An events hatte ich zu aller erst gedacht, und wollte es ganz modern mit async/await lösen und hab aber überhaupt nichts zu events in Verbindung zu async/await gefunden.

a) Ich würde i.d.R. nicht versuchen ein einziges Objekt immer wieder zu benutzen - du weisst doch gar nicht, ob das alte und die alten Werte gerade noch in Arbeit sind und was damit gerade geschieht - ich fände es z.B. echt kacke, wenn gerade einzelne Eigenschaften des objects irgendwo geloggt werden - und dann dein Task mitten im Loggen anfängt Sachen zu ändern, womit im Endeffekt Mist geloggt wird

Ja guter Punkt, werd ich so umsetzen.

b) Primäres Augenmerk wird somit dabei liegen, dass die UI nicht abschmiert // Control.Invoke bzw. WPF-Gegenstück dazu
c) Folgendes würde ich mir zu Multithreading anschauen:
>

Ich dachte mit Einführung von Tasks sollte man Threads i.d.R. nicht mehr benutzen. 🤔

Mit eurem Input hab ich folgenden Artikel gefunden (Das Stichwort war "Tasks + event" :
Writing thread-safe event handlers with the Task Parallel Library in .NET 4.0

Besonders gefällt mir das das ganze ohne Control.Invoke und Co. auskommt.
In Verbindung TaskCreationOptions.LongRunning, sollte das perfekt für meinen Anwendungszweck sein.

14.12.2015 - 00:21 Uhr

Servus,

wie kann ich am besten während eines laufenden Tasks Daten an den Aufrufer zurückgeben bzw. synchronisieren ohne das es zu Race conditions oder Dead locks kommt?

Mein Ansatz bisher:


class AsyncPolling
{
    public object Obj { get; private set; }

    public async Task PollAsync(IProgress<bool> progress, CancellationToken ct)
    {
        await Task.Run(() =>
        {
           while (true)
           {                   
               // Process some data...
               if (data_has_changed)
               {
                   Obj = ...
                   progress.Report(true);
               }
               ct.ThrowIfCancellationRequested();
          }
       }, ct);
    }
}

In der schleife frage ich ständig ein Gerät ab (per Polling, geht leider nicht anders), das die Zustände in _o speichert. _o ist relativ komplex. Die Daten sollen dann weiterverarbeitet bzw. angezeigt werden.
Ich würde ungern Obj über IProgess<T> schleusen, am liebsten wäre mir wenn ich darüber dem Aufrufer nur mitteile das neue Daten vorliegen und der die sich die aus dem Property holt.
Muss ich das Property noch locken oder ist das bei async .. await nicht nötig?

Oder ist der Ansatz zu naiv und ich bin komplett auf dem Holzweg?

05.07.2015 - 21:40 Uhr

Obfuscatoren nutzen das z.B. im dem sie dann die Variablennamen in irgendwelche exotischen (nicht druckbare) Zeichen umwandeln um die Rückverfolgbarkeit des Codes im Reflector zu erschweren. Ich glaub der .net Reflector stürzt sogar bei bestimmten Zeichen ab. Zumindest ältere Versionen.

24.06.2014 - 08:30 Uhr

XNA existiert noch. Die Jungs vom Monoprojekt haben sich der Sache angenommen und nennt sich jetzt MonoGame: MonoGame

24.06.2014 - 08:24 Uhr

Hmmm...

WinForms ist auch nicht für 2D Spiele gedacht. Wenn das performant werden soll wirst du um ein GameFramework (z.B. MonoGame) nicht herum kommen.

13.05.2014 - 10:02 Uhr

Eigentlich OT:
Sinn macht es aber z.B. bei Programmen die als "Systemerweiterung" angesehen werden können.
Ich benutze eine erweiterte Taskleiste für den zweiten Monitor und das bringt im SystemMenu einige sinnvolle Einträge unter. z.B. Fenster auf den anderen Monitor verschieben.

13.05.2014 - 09:55 Uhr

VBA steht auch für Visual Basic for Applicatios. (Excel, Word Scripting). Darauf bezieht sich auch der verlinkte Artikel.

Hast du die COM Interop Tutorials schon gelesen?
Da steht eigentlich alles wissenswerte zu COM Objekten drin.

28.01.2014 - 16:55 Uhr

Einfach in der HTML code Ansicht rechtsklick auf das element -> "XPath kopieren".
Beim darüberfahren zeigt er dir den Xpath schon als hover an.
Klappt auch mit xml wunderbar.

Ach ja: Wir reden von dem externen Plugin Firebug, NICHT von den eingebauten "Entwicklertools", die bieten die Funktion nicht.

19.01.2014 - 10:59 Uhr

Bei Audio schwöre ich auf die Audio Library Bass die eine tolle .net API hat.

Damit sollte dein unterfangen Problemlos möglich sein,

07.12.2013 - 20:54 Uhr

Servus,

die equal() Methode verglicht NICHT ob es sich um das gleiche Bitmap handelt sondern ob die beide Objekte(!) identisch sind. Siehe: Object.Equals-Methode (Object)

Um wirklich zu überprüfen ob es sind um die selben Bilder handelt musst du das selbt implemtieren. Das .net Framwork stellt hierzu glaube ich nichts bereit.

Google ist hier dein Freund. 😉

11.11.2013 - 20:14 Uhr

Wie hast du es manuell gemacht?

Naja, zumindest ohne selber Code zu schreiben.

Zuerst hab ich mit dem originalen C-Programm von David H. Bailey (BBP Code Directory) mir die entsprechende HEX Postion berechnen lassen, dann mit Hilfe eines Online-Converters zuerst nach Binär und dann nach ASCII Konvertiert.

Ein einzelnes MD5-Hashing sieht bei mir so aus:
String -> ASCII Byte-Array -> MD5 Byte-Array -> String mit großbuchstaben HEX-Werten (ohne Bindestriche oder so)

8o
Danke ich hatte den String in Kleinbuchstaben. Hätte auch gut selber drauf kommen können/müssen. Kopf->Tisch

Hier der Code:
Ist genau wie die "manuelle" Vorgehensweise. Nicht sonderlich elegant (geht sicher auch ohne das HEX/Binär String konvertiere) und mehr als 50 Zeilen aber es funktioniert!


using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Security.Cryptography;

namespace BBP
{
    class Program
    {
        static void Main(string[] args)
        {
            const string testHash = "182C3950020DBE5969AF859ADF93BBD4";
            double pid, s1, s2, s3, s4;

            // Vorherige "Hex-Nachkommastelle" zur gesuchten Position finden
            int id = 787471 / 4; // 196867;

            // Hex-Nachkommastellen berechnen
            s1 = BBP.Series(1, id);
            s2 = BBP.Series(4, id);
            s3 = BBP.Series(5, id);
            s4 = BBP.Series(6, id); 
            pid = 4 * s1 - 2 * s2 - s3 - s4;
            pid = pid - (int)pid + 1;
            string hex = BBP.Ihex(pid);

            // In Binärstring umwandeln und Bit-Position korrigieren
            string bin = HexToBinString(hex).Substring(787471 % 4 - 1);
            // In Bytes umwandeln 
            byte[] bytes = BinStringToByte(bin);
            // und ASCII decodieren
            string word = Encoding.ASCII.GetString(bytes, 0, 3);
            Console.WriteLine("Wort: {0}", word);

            // Testen
            MD5 md5 = MD5.Create();
            string hash = word;
            for (int i = 0; i < 1000000; i++)
                hash = GetMd5Hash(md5, hash);

            Console.WriteLine("Hash: {0}", hash);
            Console.WriteLine("Test-Hash: {0}", testHash);
            Console.WriteLine("Hashes are{0} equal!", hash != testHash ? " not" : "");
            
            Console.ReadLine();
        }

        // Hilfsmethoden

        static string GetMd5Hash(MD5 md5Hash, string input)
        {

            byte[] data = md5Hash.ComputeHash(Encoding.ASCII.GetBytes(input));
            StringBuilder sBuilder = new StringBuilder();
            for (int i = 0; i < data.Length; i++)
                sBuilder.Append(data[i].ToString("X2"));

            return sBuilder.ToString();
        }

        static byte[] BinStringToByte(string binstring)
        {
            var bytesAsStrings =
                                binstring.Select((c, i) => new { Char = c, Index = i })
                                     .GroupBy(x => x.Index / 8)
                                     .Select(g => new string(g.Select(x => x.Char).ToArray()));

            return bytesAsStrings.Select(s => Convert.ToByte(s, 2)).ToArray();
        }

        static string HexToBinString(string hexstring)
        {
            return String.Join(String.Empty,
                        hexstring.Select(
                        c => Convert.ToString(Convert.ToInt32(c.ToString(), 16), 2).PadLeft(4, '0')));
        }
    }

    /// <summary>
    /// "Quick and dirty" Port des orginalen C Codes von David H. Bailey 
    /// </summary>
    static class BBP
    {
        public static string Ihex(double x)
        {
            int i;
            double y;
            StringBuilder sb = new StringBuilder();
            string hx = "0123456789ABCDEF";

            y = Math.Abs(x);
            for (i = 0; i < 16; i++)
            {
                y = 16 * (y - Math.Floor(y));
                sb.Append(hx[(int)y]);
            }
            return sb.ToString();
        }

        /// <summary>
        /// This routine evaluates the series  sum_k 16^(id-k)/(8*k+m) 
        /// using the modular exponentiation technique
        /// </summary>
        /// <param name="m"></param>
        /// <param name="id"></param>
        /// <returns></returns>
        public static double Series(int m, int id)
        {
            int k;
            double ak, p, s, t;
            double eps = 1e-17;

            s = 0;
            /*  Sum the series up to id. */
            for (k = 0; k < id; k++)
            {
                ak = 8 * k + m;
                p = id - k;
                t = Expm(p, ak);
                s = s + t / ak;
                s = s - (int)s;
            }

            /*  Compute a few terms where k >= id. */
            for (k = id; k <= id + 100; k++)
            {
                ak = 8 * k + m;
                t = Math.Pow(16, (double)(id - k)) / ak;
                if (t < eps) break;
                s = s + t;
                s = s - (int)s;
            }
            return s;
        }
        /// <summary>
        /// expm = 16^p mod ak.  This routine uses the left-to-right binary 
        /// exponentiation scheme
        /// </summary>
        /// <param name="p"></param>
        /// <param name="ak"></param>
        /// <returns></returns>
        private static double Expm(double p, double ak)
        {
            int i, j;
            double p1, pt, r;
            int ntp = 25;
            double[] tp = new double[ntp];
            int tp1 = 0;

            /*  If this is the first call to expm, fill the power of two table tp. */
            if (tp1 == 0)
            {
                tp1 = 1;
                tp[0] = 1;

                for (i = 1; i < ntp; i++) 
                    tp[i] = 2 * tp[i - 1];
            }

            if (ak == 1) 
                return 0;

            /*  Find the greatest power of two less than or equal to p. */
            for (i = 0; i < ntp; i++) if (tp[i] > p) break;

            pt = tp[i - 1];
            p1 = p;
            r = 1;

            /*  Perform binary exponentiation algorithm modulo ak. */
            for (j = 1; j <= i; j++)
            {
                if (p1 >= pt)
                {
                    r = 16 * r;
                    r = r - (int)(r / ak) * ak;
                    p1 = p1 - pt;
                }
                pt = 0.5 * pt;
                if (pt >= 1)
                {
                    r = r * r;
                    r = r - (int)(r / ak) * ak;
                }
            }

            return r;
        }
    }
}

11.11.2013 - 11:43 Uhr

Hmm..

Zur Pi Aufgabe:

Ich glaube die Lösung ist:

"mib" 8) 8)

Code folgt, das ist nur "manuell" ermittelt. :evil:

Bin mir aber nicht sicher, da ich bei MD5 ins Schleudern komme. 🤔

Brechnest du die MD5 Summe 1 Mio mal jeweils vom HEX-String oder direkt vom Byte-Array? ?(

05.11.2013 - 21:02 Uhr

Mist zu langsam.... X(

Aber deine Encode Methode ist doch arg umständlich...

Hier ausser Konkurrenz meine in 8 Zeilen:


static Bitmap Encode(int height, string message)
{
    int width = message.Length * height;
    Bitmap bitmap = new Bitmap(width, height);
    using (Graphics g = Graphics.FromImage(bitmap))
    {
        for (int i = 0, j = 0; i < width; i += height, j++)
            g.FillRectangle(new SolidBrush(Color.FromArgb(255, message[j], message[j], message[j])), new Rectangle(i, 0, height, height));
    }
    return bitmap;
}

06.10.2013 - 17:21 Uhr

Die Felder müssen mit new initialisiert werden, auch wenn es innere Klassen sind.

Das kannst du entweder gleich bei der defintion machen:



public SourceInfo Ursprungsbild = new SourceInfo();
 public ProcessedInfo Arbeitskopie = new ProcessedInfo();

oder du initialisierst sie in einem Konstruktor:


public TabPicture()
{
   this.Ursprungsbild = new SourceInfo();
   this.Arbeitskopie = new ProcessedInfo();
}

Aber ich denke du hast OOP noch nicht richtig verstanden . Daher der Hinweis auf [Hinweis] Wie poste ich richtig? Punkt 1.1 1.1.1

Warum hast du zwei Klassen die exakt gleich aufgebaut sind SourceInfo und ProcessedInfo?
Du brauchst nur eine Klasse:

z.B:


 public ImageInfo SourceInfo = new ImageInfo();
 public ImageInfo ProcessedInfo = new ImageInfo();


public class ImageInfo
{
    public Image Bild { get; set; }
    public int Dateigröße { get; set; }
    public int Breite { get; set; }
    public int Höhe { get; set; }
}
05.10.2013 - 16:52 Uhr
a = b + 0*(b=a)  

Schau dir mal das Konstrukt im Reflector an und staune was der Compiler daraus macht. 8o

Oder ist das etwas absicht? :evil:

Noch lustiger ist was sich der C# Parser daraus bastelt. Erst wenn man sich die IL direkt anschaut wird klar was der Compiler daraus macht.

PS:

Meine Ergebnisse:
(Gemessen mit Stopwatch)

Methode Aratar:
106 ms

Methode DerKleineTomy:
64 ms

Methode zommi:
64 ms

Methode dr4g0n76:
64 ms

Methode Th69:
96 ms

17.09.2013 - 15:13 Uhr

Sory das ich mich erst jetzt melde:

pdelvo lösung ist korrekt und war der erste. Du bist dran.

Meine Lösung sieht fast genau so aus. 😁

12.09.2013 - 10:48 Uhr

Vielleicht hat ja jemand Lust darauf:

Ich suche eine Implementierung für folgende Erwieterungsmethode:


public static bool Contains<T>(this IEnumerable<T> enumerable, IEnumerable<T> item, IEqualityComparer<T> comparer)

Die Überladung soll prüfen ob innerhalb einer Auflistung die selben Elemente einer anderen Auflistung vorkommen in der gleichen Reihenfolge und Anzahl an beliebiger Stelle.
Beispiel:

A ("enumerable"):
*a *b *c *d *e *f *g

B ("item):
*c *d

Soll TRUE ergeben:

ebenso:
*a *b

oder
*e *f *g

aber nicht:
*b *c *e

oder
*f *g *h

27.07.2013 - 14:44 Uhr

Danke gfoidl! 👍

Mein persönlicher Held des Tages! 8)

Wenn man es mal verstanden hat wird's klar:

Der Grund ist der Gleiche warum es keine Überladungen gibt die sich nur durch den Rückgabewert unterscheiden.

Das ist einer der Tatsachen die ich bisher einfach als "Gott" bzw. Compiler gegeben hingenommen habe.

26.07.2013 - 21:49 Uhr

Danke,

Klar, bei dem Typparameter hatte ich ein kleines Brett vorm Kopf! So geht's einfacher.
😁

Das sich der Compiler die Methoden nicht auseinander halten kann ist mir schon klar.

Was ich aber noch wie vor faszinierend finde, ist die Tatsache das er bei es bei der Methode ohne Rückgabewert es schafft die richtige Methode auszuwählen, sobald die Methode aber einen Rückgabewert hat kommt er ins Schleudern und man muss nach helfen.

26.07.2013 - 17:53 Uhr

Servus,

ich hab mal eine Verständinsfrage:

Ich habe eine Methode die einen Delegaten als Parameter entgegen nimmt. Für die unterschiedlichen Signaturen ist die Methode überladen.

Für Methoden mit Rückgabewert Func<T>, für die ohne Action(<T>).

Beispiel:



public static void Foo(Action func)
{
   //... 
}

public static T Foo<T>(Func<T> func)
{
   //...
}


Jetzt wirds schräg:

Das funktioniert wie erwartet:


static void Bar()
{
   //...
}

// ...

Foo(Bar);

Folgendes nicht:



static int FooBar()
{
   //...
}

Foo(FooBar);

Da:> Fehlermeldung:

Der Aufruf unterscheidet nicht eindeutig zwischen folgenden Methoden und Eigenschaften: "Qux.Foo(System.Action)" und "Qux.Foo<int>(System.Func<int>)"

Ich muss stattdessen explizit einen Func<T> Delegaten erstellen:


Foo(new Func<int>(FooBar));

Warum wird der Action Delegat erkannt aber nicht den Func<T> ?
Ist bei den anderen Überladungen von Action und Func (also mit mehreren Parametern) das gleiche.

Ist zwar kein Problem, den Delegagten zu erstellen, es wundert mich nur warum ich das überhaupt machen muss. 🤔

01.07.2013 - 11:48 Uhr

Warum brauchst du unbedingt ClickOnce?

Erstelle die Anwendung auf "Release" neu und und schon hast du eine ganz normale .exe in deinem Projekt Verzeichniss (bin/Release).

21.06.2013 - 01:14 Uhr

Hmm..

ich verstehe nicht warum du umständlich erst den String zerlegst, in ein Array splittest und dann darüber iterierst anstatt es gleich komplett mit regex zu machen.
Dann hast du sofort die Position des Wortes.

19.06.2013 - 11:20 Uhr

Soweit ich weiß hat Platinum UPnP ein .net Binding.

12.06.2013 - 21:05 Uhr

Wenn ich es richtig verstanden habe geht es aber um halb transparenten Text.
Und die ForeColor Eigenschaft ignoriert leider den Alpha Kanal.

Umständliche Lösung:
Verwende statt des Labels eine PictureBox, zeichne den Text in ein Bitmap(da wird Transparenz unterstützt) und zeige das in der PictureBox an.

12.06.2013 - 17:12 Uhr

Genau, Enum.Has Flag verweden!

Noch ne kurze Erklärung zu der Fehlermeldung:
Weil C# im if einen boolschen Wert erwartet.
In C (C++ schleppt die Altlasten ja mit) gibt's ja kein bool. Im if wird einfach jeder wert ungleich 0 als wahr ausgewertet.

Wenn du das C Verhalten nachbilden willst:


if( di & PORT1BITS.SWITCH1 != 0)

Aber besser Enum.Has Flag verweden!

31.05.2013 - 16:27 Uhr

Manche Webseiten prüfen ob die Abfrage wirklich von einem Browser kommt.
Probier mal einen UserAgentString zu setzen und dich z.B. als Firefox auszugeben:


request.UserAgent = "Mozilla/5.0 (Windows NT 6.1; WOW64; rv:23.0) Gecko/20130406 Firefox/23.0";

28.05.2013 - 14:53 Uhr

Warum nutz du nicht eine Subversion Libary für .net z.B. SharpSVN ?

06.05.2013 - 14:34 Uhr

Warum erstellt du nicht eine temporärere Datei die dann ganz normal gedruckt wird?

17.04.2013 - 19:23 Uhr

Servus,

DIN66003 nennt sich in .net "x-IA5-German", Codepage 20106.

Siehe: Code Page Identifiers
aber das "IA5 German (7-bit)" DIN66003 bedeutet, muss man wirklich wissen.

also:

Encoding.GetEncoding(20106)

// oder

Encoding.GetEncoding("x-IA5-German")


21.03.2013 - 17:02 Uhr

@Mallett und M@TUK:

B-Baum != Binärbaum

Ein B-Baum kann mehr als 2 Unterknoten haben.

18.03.2013 - 22:28 Uhr

Servus,

ich hab das ganze ganz klassisch mit einer Breitensuche gelöst (Kürzester Weg in einem Graphen).
Die ursprüngliche Klasse habe ich noch um das Property "parent" erweitert um einfacher den Weg rekonstruieren zu können.
Es wird auch der Weg zwischen zwei beliebigen (nicht nur root-Knoten "0" als Start) Knoten ("Links") gefunden, sofern er existiert, allerdings nur "nach oben" in den Objektbaum hinein, nicht nach unten, da die Objekte keinen "Eltern" Knoten kennen, und mein Algorithmus abbricht wenn er das Kind gefunden hat, ansonsten müsste der komplette Objektbaum durchlaufen werden um die "Eltern"-Beziehung herzustellen.

Ich hoffe es reicht, trotzdem:


class Link
{
    public int ID { get; set; }
    public List<Link> Links { get; set; }

    public Link Parent { get; set; }

    public Link(int id)
    {
        this.ID = id;
        this.Links = new List<Link>();
    }

    private static Link BfsSearch(Link start, int goalID)
    {
        Queue<Link> queue = new Queue<Link>();
        Link endLink = null;
        List<Link> visited = new List<Link>();

        queue.Enqueue(start);
        visited.Add(start);

        while (queue.Count != 0)
        {
            Link curLink = queue.Dequeue();

            if (curLink.ID == goalID)
            {
                endLink = curLink;
                break;
            }

            foreach (Link child in curLink.Links)
            {
                if (!visited.Contains(child))
                {
                    child.Parent = curLink;
                    visited.Add(child);
                    queue.Enqueue(child);
                }
            }
        }

        return endLink;
    }

    public string GetShortestWay(int startID, int goalID)
    {
        Link endLink = BfsSearch(startID != this.ID ? GetLinkById(startID) : this, goalID);

        if (endLink == null)
            return string.Empty;

        List<int> way = new List<int>();
        while (endLink.ID != startID)
        {
            way.Add(endLink.ID);
            endLink = endLink.Parent;
        }
        way.Add(startID);
        way.Reverse();
        return String.Join(" -> ", way);

    }

    public Link GetLinkById(int id)
    {
        return BfsSearch(this, id);
    }
        
    // ... (siehe oben)

}

18.02.2013 - 23:18 Uhr

Ja, aber das würde dann doch bedeuten, dass ein für 4.0 kompiliertes Programm auf einem System mit (nur) 2.0 nicht mehr laufen würde oder?

Genau!
Ist ja auch logisch, denn mit jeder neuen Frameworkversion kamen neue Features hinzu.
Wie soll z.B. eine 4.0 WPF Anwendung unter 2.0 laufen? Die benötigten Assembly sind ja nicht vorhanden, außerdem hat sich die Runtime Version auch geändert.

Und die Bedingung ist, dass ich EINE .exe habe, die - egal was für ein Framework installiert ist - läuft!

Wer erstellt den solche Bedingungen?!? 8o

Dann musst dich auf Frameworkversion 1.1 beschränken, nur 1.1er Assemblys laufen auf allen anderen Versionen.*

* = und selbst das ist nicht zu 100% Garantiert!

11.02.2013 - 19:25 Uhr

Wenn Kombinationswerte möglich sein sollen, musst du das FlagsAttribute angeben.

Lies dir mal enum (C#-Referenz) durch.

Hat aber nichts mit der Serialisierung zu tun.

Edit:
Zu langsam...