Willkommen auf myCSharp.de! Anmelden | kostenlos registrieren
 | Suche | FAQ

Hauptmenü
myCSharp.de
» Startseite
» Forum
» Suche
» Regeln
» Wie poste ich richtig?

Mitglieder
» Liste / Suche
» Wer ist online?

Ressourcen
» FAQ
» Artikel
» C#-Snippets
» Jobbörse
» Microsoft Docs

Team
» Kontakt
» Cookies
» Spenden
» Datenschutz
» Impressum

  • »
  • Portal
  • |
  • Mitglieder
Beiträge von Spook
Thema: Wo finde ich das .NET-Equivalent zum Java-Bitset?
Am im Forum: Rund um die Programmierung

Hallo,

System.Collections.BitArray sollte dem sehr nahe kommen.

Spooky

Thema: mehrere Bilder in einem BLOB speichern
Am im Forum: Datentechnologien

Hallo scoda,

ich würde den Blob so aufbauen:

[Länge der Bilddaten][Bilddaten][Länge der Bilddaten][Bilddaten][Länge der Bilddaten][Bilddaten]

So kannst du einfach Bilder anfügen oder durch die Datei zum x-ten Bild springen.

Spooky

Thema: PerformanceCounter: Processor / % Processor Time / _Total = immer 0.0
Am im Forum: Basistechnologien und allgemeine .NET-Klassen

Hallo lord_fritte,

siehe Dokumentation:

Zitat
Wenn der berechnete Wert eines Zählers von zwei Zählerlesevorgängen abhängt, gibt der erste Lesevorgang 0,0 zurück. Das Zurücksetzen der Leistungsindikatoreigenschaften, um einen anderen Indikator anzugeben, entspricht dem Erstellen eines neuen Leistungsindikators, und beim ersten Lesevorgang mit den neuen Eigenschaften wird 0,0 zurückgegeben. Die empfohlene Verzögerungszeit zwischen Aufrufen der NextValue-Methode beträgt eine Sekunde, um es dem Indikator zu ermöglichen, den nächsten inkrementellen Lesevorgang auszuführen.

PerformanceCounter pCounter = new PerformanceCounter("Processor", "% Processor Time", "_Total");
pCounter.NextValue();
while (true)
{
    Thread.Sleep(1000);
    Console.WriteLine(pCounter.NextValue());
}

Spooky

Thema: [gelöst] Überladen von "==": Null abfangen?
Am im Forum: Basistechnologien und allgemeine .NET-Klassen

Wie dN!3L schon geschrieben hat ist ReferenceEquals (oder der cast nach Object) eine Lösung, hier in einem einfachen Beispiel:

		class Point
		{
			public double X { get; set; }
			public double Y { get; set; }

			public static bool operator ==(Point a, Point b)
			{
				if (ReferenceEquals(a, b))
				{
					return true;
				}
				if (ReferenceEquals(a, null) || ReferenceEquals(b, null))
				{
					return false;
				}
				return ((a.X == b.X) && (a.Y == b.Y));
			}

			public static bool operator !=(Point a, Point b)
			{
				return (!(a == b));
			}
		}

Spooky

Thema: Ansicht-Designer soll Code nicht ausführen
Am im Forum: Entwicklungs- und Laufzeitumgebung (Infrastruktur)

Hallo Tom,

vielleicht hilft dir dies weiter.

Component.DesignMode-Eigenschaft

Spooky

Thema: 32bit Bitmap in 16bit Bitmap umwandeln
Am im Forum: Grafik und Sound

Hallo S.R.,

Zitat von S.R.
Leider ist das Ergebnis weiterhin, dass result.bmp genauso groß ist und die gleiche Auflösung hat wie test-1.bmp. Hat jemand einen weiteren Tipp auf LAger, was hier schief läuft?

Bei mir liefert die Clone Methode schon ein 32-bit Bild zurück. Von daher ist es nur logisch, dass die Datei dann auch 32-bit ist.

Du könntest diese Methode verwenden:

public static Bitmap ConvertBitmap(Bitmap bitmap, PixelFormat format)
{
    if (bitmap == null)
    {
        throw new ArgumentNullException("bitmap");
    }

    Bitmap result = null;
    try
    {
        Rectangle rect = new Rectangle(0, 0, bitmap.Width, bitmap.Height);
        result = new Bitmap(bitmap.Width, bitmap.Height, format);

        BitmapData dstData = result.LockBits(rect, ImageLockMode.WriteOnly, format);
        try
        {
            BitmapData srcData = new BitmapData();
            srcData.Scan0 = dstData.Scan0;
            srcData.Stride = dstData.Stride;

            bitmap.LockBits(rect, ImageLockMode.ReadOnly | ImageLockMode.UserInputBuffer, format, srcData);
            bitmap.UnlockBits(srcData);
        }
        finally
        {
            result.UnlockBits(dstData);
        }
    }
    catch
    {
        if (result != null)
        {
            result.Dispose();
        }
        throw;
    }
    return result;
}

Dabei solltest du jedoch beachten, dass GDI+ bzw .NET kein Format16bppArgb1555 unterstützen. D.h. du musst dich mit Format16bppRgb555 oder Format16bppRgb565 begnügen.

Spooky

Edit: Methode geändert, sodass keine 3. temporäre Bitmap erzeugt wird. So schreibt die eine Bitmap die Pixeldaten direkt in die andere.

Thema: DllImport - LPByte mit Marshal.AlocHGlobal ... CMD-Fenster schließt erst nach etwa 10s (siehe unten)
Am im Forum: Rund um die Programmierung

Hallo ibuddy,

von den Namen der Datentypen her würde ich die Klasse so definieren:

        [StructLayout(LayoutKind.Sequential, Size = 20)] // event. in der dllimport dann als "[in,out] S_RESOLUTION_PARAMS ResParam" aufrufen
        public class S_RESOLUTION_PARAMS
        {
            public short wOffsetX;       // i16 X offset of ROI (relative to visible area).
            public short wOffsetY;       // i16 Y offset of ROI (relative to visible area).
            public ushort wSizeX;         // u16 X size (width, columns) of ROI.
            public ushort wSizeY;         // u16 Y size (height, lines) of ROI.
            public uint dwSkip;         // u32 X- and Y- Skip Settings (see XY_SKIP_NONE).
            public uint dwBin;          // u32 X- and Y- Bin Settings (see XY_BIN_NONE).
            public byte bKeepExposure;  // u08 keep constant exposure (true=yes, false=no)
        };

Durch die Angabe der absoluten Größe kannst du das Array weglassen (welches eh nur fürs Alignment ist).

Zu der C++ Anweisung:
"pResCap = (S_RESOLUTION_CAPS*) new (BYTE[dwCapSize]);"

In C++ kannst du Speicher mit dem new Operator allokieren. In dem Fall wird ein byte-array der Größe "dwCapSize" allokiert. Durch den Cast (S_RESOLUTION_CAPS*) kann nun der Speicher so verwendet werden, als sei es ein Array von "S_RESOLUTION_CAPS".
new

Spooky

Thema: Unmanaged Int-Pointer in managed float-Array umwandeln
Am im Forum: Basistechnologien und allgemeine .NET-Klassen

Hallo,

         public static float[][] GetMatrix(IntPtr ptr)
        {
            float[][] result = new float[4][];
            for (int i = 0; i < 4; i++)
            {
                IntPtr arrayPtr = Marshal.ReadIntPtr(ptr, i);
                float[] floats = new float[4];
                Marshal.Copy(arrayPtr, floats, 0, 4);
                result[i] = floats;
            }
            return result;
        }

So könnte es funktioneren, wenn es ein einfach verschachteltes Array ist.

Spooky

Thema: Serialisierung fixed byte[] in Struct
Am im Forum: Basistechnologien und allgemeine .NET-Klassen

Hallo,

so sollte es gehen:


[StructLayout(LayoutKind.Sequential, Size = 512), Serializable]
public struct DMXStep : ISerializable
{
    private byte m_firstByte;

    private unsafe DMXStep(SerializationInfo info, StreamingContext context)
    {
        fixed (byte* p = &m_firstByte)
        {
            byte[] data = (byte[])info.GetValue("DATA", typeof(byte[]));
            for (int i = 0; i < 512; i++)
                p[i] = data[i];
        }
    }
    
    public unsafe byte this[int index]
    {
        get
        {
            fixed (byte* p = &m_firstByte)
            {
                return p[index];
            }
        }
        set
        {
            fixed (byte* p = &m_firstByte)
            {
                p[index] = value;
            }
        }
    }

    #region ISerializable Member

    unsafe void ISerializable.GetObjectData(SerializationInfo info, StreamingContext context)
    {
        fixed (byte* p = &m_firstByte)
        {
            byte[] data = new byte[512];
            for (int i = 0; i < 512; i++)
                data[i] = p[i];
            info.AddValue("DATA", data);
        }
    }

    #endregion
}

Spooky

Thema: Serialisierung fixed byte[] in Struct
Am im Forum: Basistechnologien und allgemeine .NET-Klassen

Hallo,

das unsafe byte-Array ist ein vom Compiler generierter Typ, der nicht als serialisierbar gekennzeichnet ist:

[StructLayout(LayoutKind.Sequential, Size=x), CompilerGenerated, UnsafeValueType]
public struct <bytes>e__FixedBuffer0
{
    public byte FixedElementField;
}

Spooky

Thema: FileInfo.ToString() liefert nach file.MoveTo() FullName statt Name
Am im Forum: Basistechnologien und allgemeine .NET-Klassen

Hallo,

ToString() gibt den String zurück, der beim erstellen/verschieben übergeben wurde.

Spooky

Thema: Prozess ID des Aufrufenden Prozess' ermitteln.
Am im Forum: Basistechnologien und allgemeine .NET-Klassen

Hallo inva,

mit WMI kannst du die ParentProcessId auslesen:

static bool TryGetParentProcessId(out int id)
{
	try
	{
		int ownId = Process.GetCurrentProcess().Id;
		ManagementObjectSearcher searcher = new ManagementObjectSearcher("SELECT * FROM Win32_Process WHERE ProcessId=" + ownId);
		foreach (ManagementBaseObject row in searcher.Get())
		{
			id = (int)(uint)row["ParentProcessId"];
			return true;
		}
	}
	catch
	{

	}
	id = 0;
	return false;
}

static void Main(string[] args)
{
	int id;
	if (TryGetParentProcessId(out id))
		Console.WriteLine(Process.GetProcessById(id).ProcessName+ " called me.");
	else
		Console.WriteLine("Unable to identify caller.");
}

Spooky

Thema: Point-array von c# nach c++
Am im Forum: Rund um die Programmierung

Hallo,

eine Möglichkeit wäre einen Custom Marshaler zu implementieren. Dann könnten die PInvokes zB so aussehen:

[DllImport("some.dll")]
private static extern bool SomeFunction(
    [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(PolygonMarshaler))] Polygon polygon);

[return: MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(PolygonMarshaler))]
[DllImport("some.dll")]
private static extern Polygon SomeOtherFunction();

Die Implementierung könnte dann so aussehen:

public sealed class Polygon
{
    public Header header;
    public Parms parms;
    public PointD[] points;
}

[StructLayout(LayoutKind.Sequential, Size = 1)]
public struct Header { }

[StructLayout(LayoutKind.Sequential, Size = 1)]
public struct Parms { }

public struct PointD
{
    public double x;
    public double y;
}

internal sealed class PolygonMarshaler : ICustomMarshaler
{
    private unsafe struct Poly
    {
        public Header header;
        public Parms parms;
        public ushort pointCount;
        public fixed PointD points[1];
    }

    private static ICustomMarshaler m = new PolygonMarshaler();

    private static ICustomMarshaler GetInstance(string s)
    {
        return m;
    }

    #region ICustomMarshaler Member

    public void CleanUpManagedData(object ManagedObj)
    {

    }

    public void CleanUpNativeData(IntPtr pNativeData)
    {
        Marshal.FreeHGlobal(pNativeData);
    }

    public unsafe int GetNativeDataSize()
    {
        return sizeof(Poly);
    }

    public unsafe IntPtr MarshalManagedToNative(object ManagedObj)
    {
        if (!(ManagedObj is Polygon))
            return IntPtr.Zero;

        Polygon polygon = (Polygon)ManagedObj;

        int size = sizeof(Poly);
        if ((polygon.points != null) && (polygon.points.Length > 1))
            size += ((polygon.points.Length - 1) * sizeof(PointD));
        Poly* ptr = (Poly*)Marshal.AllocHGlobal(size);

        ptr->header = polygon.header;
        ptr->parms = polygon.parms;
        ptr->pointCount = (ushort)(polygon.points == null ? 0 : polygon.points.Length);
        for (int i = 0; i < ptr->pointCount; i++)
            ptr->points[i] = polygon.points[i];

        return (IntPtr)ptr;
    }

    public unsafe object MarshalNativeToManaged(IntPtr pNativeData)
    {
        if (pNativeData == IntPtr.Zero)
            return null;

        Polygon result = new Polygon();
        Poly* ptr = (Poly*)pNativeData;

        result.header = ptr->header;
        result.parms = ptr->parms;
        result.points = new PointD[ptr->pointCount];

        for (int i = 0; i < ptr->pointCount; i++)
            result.points[i] = ptr->points[i];

        return result;
    }

    #endregion
}

Hier fehlen noch die konkreten Implementierungen von Header und Parms.

Ich hoffe du kannst damit einen Einstieg finden. Vielleicht lässt sich das auch eleganter nur unter der Verwendung der unsafe struct Poly lösen, kommt ganz drauf an, ob und wie du die eigentliche Klasse verwenden willst.

Spooky

Thema: verschiedene Elemente in einem Array zählen
Am im Forum: Basistechnologien und allgemeine .NET-Klassen

Hallo,

so kannst du die einzelnen Elemente zählen:

            string[] myArray = new string[10] { "0", "0", "0", "0", "0", "1", "1", "1", "1", "2" };
            Dictionary<string, int> dict = new Dictionary<string, int>();
            int c;
            foreach (string s in myArray)
            {
                if (!dict.TryGetValue(s, out c))
                    c = 0;
                dict[s] = (c + 1);
            }
            foreach (KeyValuePair<string, int> kvp in dict)
            {
                //
            }

Spooky

Thema: Point-array von c# nach c++
Am im Forum: Rund um die Programmierung

Hallo,

der Member points ist kein Zeiger auf ein PointArray sondern ein in die Struct eingebettetes Array von konstanter Größe 1.
Dadurch kann man wie bei einem Array auf die Punkte zugreifen. Es muss natürlich, wie Th69 schon geschrieben hatte, für jeden weiteren Punkt auch mehr Speicher allokiert werden:

tagApiPolygonObjectV1_NEW *poly =
   (tagApiPolygonObjectV1_NEW *)malloc(sizeof(tagApiPolygonObjectV1_NEW) + (sizeof(IN_POINT) * 3));
poly->pointCount = 4;
poly->points[0] = ...;
poly->points[1] = ...;
poly->points[2] = ...;
poly->points[3] = ...;

Spooky

Thema: Eure Kritik: Fraction struct
Am im Forum: Rund um die Programmierung

Hallo m0rius,

du könntest auch den Typ Decimal näher betrachten (statische Operatoren, Konstanten, sinnvolle Methoden).

Spooky

Thema: c++ code zu c#: unsigned char ** buffer
Am im Forum: Rund um die Programmierung

Hallo,


IntPtr ptr = Marshal.AllocHGlobal(16635);
IntPtr ptrptr = Marshal.AllocHGlobal(ptr);

Dieser Code erzeugt keinen Zeiger auf den ersten Buffer, sondern zwei von einander komplett unabhängige Buffer.

Die wohl sinnigste Deklaration wäre (wie schon gesagt) ref IntPtr.

Allerdings kommt dann das nächste Problem ...
In deinem Code wird der allokierte Speicher nicht wieder freigegeben, was man natürlich noch einbauen könnte. Jedoch wird einem der Zeiger auf den allokierten Speicher ...
*buffer+=netLen;

unter der Nase weg verändert ... (guter Stil?). Zwar wird der veränderte Wert in len wieder zurückgegeben, aber nun muss man entweder wieder rückwerts rechnen, oder sich den Zeiger doppelt vorhalten um auf die Daten zuzugreifen und den Speicher wieder freizugeben.

Wenn ich eine Funktion mit einem Buffer habe, gehe ich davon aus, dass der Buffer gefüllt wird mit Daten. Dabei kann ich ein ggf ein Offset angeben und die Länge des Buffers. Aber eine Funktion sollte dem Aufrufer nicht die Zeiger "verbiegen".

Thema: EXIF-Daten auslesen -> komische zeichen
Am im Forum: Grafik und Sound

http://www.exif.org/Exif2-2.PDF

Am besten nach den Konstanten suchen, und die Daten-Typen beachten (signed/unsigned). Mit Hilfe der BitConverter Klasse sollte das recht einfach gehen.

Spooky

Thema: DLLImport: Wie void* als Parametertyp umsetzen?
Am im Forum: Rund um die Programmierung

Hallo,

das out ist nicht nötig, da .NET den Zeiger auf das erste Array-Element übergibt und die Daten direkt in dieses geschrieben werden (genau das, was vorher manuell mit unsafe erreicht werden sollte).

Spooky

Thema: DLLImport: Wie void* als Parametertyp umsetzen?
Am im Forum: Rund um die Programmierung

Hallo,

Wenn ich mir die Funktion so ansehe, gehe ich einmal davon aus, dass Parameter "Buff" ein Buffer ist in den etwas geschrieben wird, welcher die Länge "BuffLen" hat.
Das ganze funktioniert auch ganz ohne unsafe code:


[DllImport("CANAPI2.dll", EntryPoint = "CAN_GetHwParam")]
public static extern uint GetHwParam(byte hHw, ushort Param, byte[] Buff, ushort BuffLen);

...
const int buffLength = 1024;
byte[] buffer = new buffer[buffLength];
uint result = GetHwParam(0, 0, buffer, buffLength);

...


Ob die Funktion bytes, shorts, ect erwartet musst du der API entnehmen.

Spooky

Thema: Optimierung, Umwandeln von BitArray in Long und umgekehrt
Am im Forum: Basistechnologien und allgemeine .NET-Klassen

Hallo,

zum ersten ist ein long in .NET 64 Bit groß (int wäre 32 falls du das eigentlich wolltest).

Du könntest das so realisieren:


		public static int GetInt32(BitArray array)
		{
			int[] value = new int[1];
			array.CopyTo(value, 0);
			return value[0];
		}

		public static BitArray GetBitArray(int value)
		{
			return new BitArray(BitConverter.GetBytes(value));
		}

spooky

Thema: Clipboard und IEnumerable
Am im Forum: GUI: Windows-Forms

Hallo Master15,

verwende anstatt "IEnumerable<Grafikobjekt>" "Grafikobjekt[]".

Spooky

Thema: Wie binde ich die mitgelieferte DLL in mein Programm ein?
Am im Forum: Rund um die Programmierung

Hallo Todesengel,

vermutlich ist diese dll für 32bit compiliert. Die .NET Anwendung passt sich allerdings dem OS an und läuft nun als 64bit, was so nicht funktionieren kann, da Pointer unter 32bit und 64bit unterschiedlich groß sind.

Entweder das .NET Programm fest für 32 bit compilieren oder eine 64bit Version der dll verwenden.

Spooky

Thema: Methode aus Assembly/DLL laden und ausführen...
Am im Forum: Basistechnologien und allgemeine .NET-Klassen

Hallo kds,

hier ein kleines Beispiel...

namespace ConsoleApplication1
{
    class Program
    {
        static void Main(string[] args)
        {
            Assembly a = Assembly.GetEntryAssembly(); // Hier ist die gelandene Assembly
            // Der exakte Name incl. Namespace
            Type t = a.GetType("ConsoleApplication1.Hallodll");
            // Instanz erzeugen, da Hallo() nicht statisch ist
            object o = Activator.CreateInstance(t);
            // Auf der Instanz die Methode aufrufen
            t.InvokeMember("Hallo", BindingFlags.Instance | BindingFlags.Public | BindingFlags.InvokeMethod, null, o, null);
            // Ohne Instanz die statische Methode aufrufen
            t.InvokeMember("HalloStatic", BindingFlags.Static | BindingFlags.Public | BindingFlags.InvokeMethod, null, null, null);
        }
    }

    class Hallodll
    {
        public void Hallo()
        {
            Console.WriteLine("Hallo");
        }

        public static void HalloStatic()
        {
            Console.WriteLine("Hallo");
        }
    }
}

Spooky

Thema: Probleme beim überladen von Operatoren in generischen Klassen
Am im Forum: Basistechnologien und allgemeine .NET-Klassen

Hallo Gogonfa,

falls du .NET 3.5 verwendest, könntest du dir mal folgende Lib anschauen:http://www.yoda.arachsys.com/csharp/miscutil/

In dieser gibt es eine Klasse (MiscUtil.Operator<T>) mit der generische Operatoren möglich sind wie zB:


...
T t = Operator<T>.Add(val1, val2);

Spook

Thema: [erledigt] DLL benutzen (DevIL.NET/.pcx Anzeigen)
Am im Forum: Rund um die Programmierung

Hallo hackfix,

ich habe eben die Version 1.3 herunter geladen und mal getestet.
Du musst einen Verweis auf die Datei "DevIL.NET2.dll" in dein Project einfügen.
Danach kannst du mit der Klasse "DevIL.DevIL" Bilddateien laden.

Bitmap bitmap = DevIL.DevIL.LoadBitmap(@"......");
pictureBox.Image = bitmap;

Zusätzlich muss du noch die Datei "DevIL.dll" ins Ausgabeverzeichnis kopieren (die Datei ist die eigentlich Bibliothek, die anderen der .NET Wrapper).

Spooky

Thema: [gelöst] Warum sind die Klassen im Framework nicht partial?
Am im Forum: Basistechnologien und allgemeine .NET-Klassen

Zitat von Golo Roden
Nur würde ich mal behaupten, dass es keinen Unterschied macht, ob eine Methode statisch ist oder nicht, sobald ich mindestens eine Instanz erstellt habe.

Das ist auch der Fall, daher meine Verwunderung.

Thema: enum Flag auflösen?
Am im Forum: Basistechnologien und allgemeine .NET-Klassen

Hallo lord_fritte,

Du könntest diesen Ansatz anschauen/erweitern:

static T[] Factorize<T>(T value) where T : struct
{
	Type type = typeof(T);

	if (!type.IsEnum)
		throw new ArgumentException("value");

	List<T> result = new List<T>(64);
	ulong bitField = Convert.ToUInt64(value);
	ulong bit = 1;

	for (int i = 0; i < 64; i++, bit <≤ 1)
	{
		ulong u = (bitField & bit);
		if (u != 0)
		{
			result.Add((T)Enum.ToObject(type, u));
		}
	}

	return result.ToArray();
}

Spooky

Thema: [gelöst] Warum sind die Klassen im Framework nicht partial?
Am im Forum: Basistechnologien und allgemeine .NET-Klassen

Zitat
Ist alles Speicher, der während der Ausführung permanent belegt ist.
Auf was genau beziehst du diese Aussage?

Thema: Dllimport in C# aus einer c++ DLL mit struct und Array
Am im Forum: Rund um die Programmierung

Hallo st0ne,

die C# Definitionen sollten so aussehen unter der Annahme, dass UCHAR ein 8-bit unsigned integer ist. Wenn nicht diesen einfach anpassen:

[Serializable, StructLayout(LayoutKind.Sequential)]
public sealed class eeprom_prodid
{
	public UInt16 sn;
	public UInt16 prodcode;
	public SByte hwrel;
	public SByte hwver;
	[MarshalAs(UnmanagedType.ByValArray, SizeConst = 6)]
	public SByte[] signature;
}

public class Native
{
	[DllImport("name_meiner_dll", EntryPoint = "funktionsname_in_der_dll")]
	public static extern int ExternalEepromRead(eeprom_prodid prodid, UInt32 addr, SByte count);
}

Spooky