Forenbeiträge von marsgk Ingesamt 1.439 Beiträge
@m0rius & JAck30lena:
Auf dem Stack wird nur 1 mal Platz für die lokale Variable temp reserviert, egal ob die Variable innerhalb oder außerhalb der Schleife deklariert wird.
Hi,
probier mal
app.CreateInstanceFromAndUnwrap (AssemblyName.GetAssemblyName (Assembly.GetAssembly (typeof (WiWQuery)).Location).Name, typeof(WiWQuery).FullName)
Hallo!
Die DirectoryInfo-Klasse wird die Informationen, wie Attribute, Zeitstempel, etc nicht speichern, sondern direkt die entsprechenden Win32-Methoden aufrufen. Aus diesem Grund wird dir eine deserialisierte Instanz der DirectoryInfo-Klasse auf einem fremden Rechner nicht viel bringen.
Erstell dir einfach ein "Data Transfer Object", welches die für dich relevanten Informationen über ein Directory speichert. Dieses kannst du dann problemlos serialieren.
Dann musst du eben herausfinden, welche Möglichkeiten einem gfa basic da bietet. Zur Not musst du halt Files oder Sockets verwenden.
Wieso willst du nicht eine andere Art von IPC verwenden?
... deswegen war sendmessage eigtl die für mich die einfachste alternative.
Und warum verwendest du nicht Windows Messages?
gibt es keine möglichkeit außer readmemmory auf einen fremden adressbereich zu zu greifen...
Nein
...oder einen komplett globalen adressbereich für den austausch zu verwenden?
Doch, Shared Memory(CreateFileMapping) aber nicht unter .Net.
Das liegt daran, dass jeder Prozesse seinen eigenen Adressraum hat, sprich ein Pointer ist nur im Kontext des jeweiligen Prozesses gültig.
Eine schlechte Lösung wäre ReadProcessMemory, ansonsten such mal im Forum nach IPC, Remoting, MW_COPYDATA, Pipes, ...
Interessant, die CryptoStream-Klasse quasi verkehrt zu benutzen. Das habe ich bisher noch nie gesehen, da habe ich zuvor nicht genau genug hingesehen.
Wenn du entschlüsseln willst, dann solltest du aber auch aus dem CryptoStream lesen und nicht schreiben...
Die SetClipboardViewer Funktion könnte dir da weiterhelfen.
Poste doch mal den relevanten Sourcecode.
Hallo Golo!
Ich habe mir gerade das Header File angesehen, sollte leicht möglich sein.
Grüße,
Georg
Einen unitialisierten(=null) Wert als Paramter übergeben, obwohl die Dll einen gültigen Pointer erwartet?
Ich meine nicht nur öffnen, sondern z.B. deinem Form zuweisen. Da habe ich mich wohl etwas ungenau ausgedrückt.
Du kannst ja mal P/Invoke Interop Assistant ausprobieren.
Hallo!
Eine OutOfMemory-Exception mit GDI+ bekommst man meist wenn das Format nicht passt oder ein "allgemeiner Fehler" aufgetreten ist, und nicht wie man am Namen vermuten könnte an zu wenig Speicher 😉.
Versuch mal das Icon mit VS zu öffnen.
Grüße
Ganz blöde Frage ist jetzt (von jemandem, der NULL Ahnung von Unmanaged-Sprachen und Interop hat), wie bekomme ich diese C-Library in mein .NET-Projekt rein?
per DllImportAttribute.
Kurz Zusammengefasst:
Den Namen der Dll im Attribute setzen, die anderen Felder kann man meistens auf default lassen.
Der Name der Funktion in C# muss dem Namen der Funktion in der Dll entsprechen.
Wäre P/Invoke der richtige Ansatz? Wenn ja, brauche ich dafür die .h-Datei? Woher bekomme ich die Namen der Methoden? ...?
In der .h-Datei solltest du alle relevanten Informationen, wie Name der Funktion, Parameter, Rückgabewert, Aufrufkonventionen sowie andere Typdefinitionen finden.
Grüße,
Georg
Hallo markus111!
Vergiss das mit dem Polling diese Lösung ist sehr ineffizient.
Ruf die Stream.Read Methode auf, diese blockiert bis Daten im Stream zum Lesen vorhanden sind. Sobald Daten im Stream vorhanden sind, werden diese in den Puffer kopiert und die Read-Methode kehrt zurück. Als Rückgabewert bekommst du die Anzahl der gelesenen Bytes und kannst bei Bedarf einen Event feuern.
Grüße,
Georg
WiX hab ich mir angesehen, ist doch eigentlich nicht viel anders als "normale" MSI?
Was verstehst du den unter normale MSI?
Wix erzeugt anhand einer Installer Beschreibung in XML eine msi Datei. *.msi Dateien kannst du auch mit anderen Tools wie Installshield oder sehr eingeschränkt mit einem VS Setup Projekt erzeugen. Ausgeführt werden diese *.msi Dateien durch den Windows Installer(msiexec /i <msidatei>).
Wo ist das Problem, Die Registry Klasse bietet Zugriff auf die einzelnen base keys(HKLM, HKCU, ...) und über die RegistryKey Klasse kannst du alle Subkeys und Werte auslesen.
regedit starten => Datei => Exportieren
Hallo Bernd23!
Die CreateEvent Funktion hat nichts mit Events im .Net Sinn gemeinsam. Die CreateEvent Funktion kannst du in C# direkt durch z.B. die ManualResetEvent Klasse ersetzen.
Komisch ist nur, dass in deinem Beispiel globale Objekte(=mit Namen) erzeugt werden und der Name an die Funktion weitergegeben wird. Das ist sehr unüblich und kann zu Fehler führen. Normalerweise wird nur das Handle(ManualResetEvent.SafeWaitHandle) an die Funktion übergeben.
Frag noch mal bei den Entwicklern der Dll nach, ob es wirklich globale Objekte sein müssen. Ansonsten würde ich mich schleunigst nach einer besseren Dll umsehen.
Grüße,
Georg
Du musst in deinem Code auch EndConnect aufrufen, sonnst bekommst du ein Speicherleck.
Wird wohl so sein, dass unter bestimmten Umständen der Vorgang synchron ausgeführt wird. Um diesen Fall zu erkennen solltest du das IAsyncResult.CompletedSynchronously Property auswerten.
Hallo!
Hier eine Quick and Dirty Lösung mit der die CPU-Auslastung eines beliebigen Prozesses beschränkt werden kann.
Da der VS Debugger ebenfalls die SupendThread Funktion verwendet, sollte die Komponente nicht auf einen Prozess angewandt werden, der gerade debuggt wird.
Ich würde diese Komponente aber nicht in Produktivumgebungen einsetzen, sondern wie svenson bereits gesagt hat die CPU Auslastung durch die Priorität regeln.
Lg
using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Runtime.InteropServices;
using System.Threading;
namespace ProcessLimiter {
public class ProcessLimiter : IDisposable {
private bool running;
private Thread watcher;
private Process target;
private float threshold;
public ProcessLimiter(Process target, float threshold) {
Target = target;
Threshold = threshold;
}
public Process Target {
get {
return target;
}
private set {
if (value == null) {
throw new ArgumentNullException("value");
}
target = value;
}
}
public float Threshold {
get {
return threshold;
}
set {
if (value < 0.0 || value > 1.0) {
throw new ArgumentOutOfRangeException("value", value, "Threshold must be between 0 and 1.");
}
threshold = value;
}
}
public void Start() {
if (!running) {
running = true;
watcher = new Thread(WatcherProc);
watcher.IsBackground = true;
watcher.Start();
}
}
public void Stop() {
running = false;
watcher = null;
}
void IDisposable.Dispose() {
Stop();
}
private void WatcherProc() {
TimeSpan currentTotalProcessorTime;
TimeSpan lastTotalProcessorTime = target.TotalProcessorTime;
Dictionary<int, IntPtr> threadHandleTable = new Dictionary<int, IntPtr>();
int watcherThreadId = GetCurrentThreadId(); ;
while (running && !target.HasExited) {
Thread.Sleep(20);
currentTotalProcessorTime = target.TotalProcessorTime;
if (currentTotalProcessorTime - lastTotalProcessorTime > TimeSpan.FromMilliseconds(200.0 * threshold)) {
lastTotalProcessorTime = currentTotalProcessorTime;
threadHandleTable.Clear();
foreach (ProcessThread t in target.Threads) {
if (t.Id == watcherThreadId) {
continue;
}
IntPtr threadHandle = OpenThread(ThreadAccess.SUSPEND_RESUME, false, t.Id);
if (threadHandle == IntPtr.Zero) {
continue;
}
SuspendThread(threadHandle);
threadHandleTable.Add(t.Id, threadHandle);
}
Thread.Sleep((int)(200.0 * (1.0 - threshold)));
foreach (KeyValuePair<int, IntPtr> item in threadHandleTable) {
ResumeThread(item.Value);
CloseHandle(item.Value);
}
}
}
}
#region Native Methods
[DllImport("kernel32.dll")]
private static extern int SuspendThread(IntPtr hThread);
[DllImport("kernel32.dll")]
private static extern int ResumeThread(IntPtr hThread);
[Flags]
public enum ThreadAccess : uint {
ALL_ACCESS = 0x1F03FF,
SYNCHRONIZE = 0x00100000,
DIRECT_IMPERSONATION = 0x0200,
GET_CONTEXT = 0x0008,
IMPERSONATE = 0x0100,
QUERY_INFORMATION = 0x0040,
QUERY_LIMITED_INFORMATION = 0x0800,
SET_CONTEXT = 0x0010,
SET_INFORMATION = 0x0020,
SET_LIMITED_INFORMATION = 0x0400,
SET_THREAD_TOKEN = 0x0080,
SUSPEND_RESUME = 0x0002,
THREAD_TERMINATE = 0x0001
}
[DllImport("kernel32.dll")]
private static extern IntPtr OpenThread(ThreadAccess dwDesiredAccess, bool bInheritHandle, int dwThreadId);
[DllImport("kernel32.dll", SetLastError=true)]
[return: MarshalAs(UnmanagedType.Bool)]
private static extern bool CloseHandle(IntPtr hObject);
[DllImport("kernel32.dll")]
private static extern int GetCurrentThreadId();
#endregion
}
}
Eine gute Erklärung gibt es hier: http://www.codeproject.com/KB/cs/begininvoke.aspx
<ul\s+id="ctl00_table_aktuelles".*?</ul> und SingleLine auswählen.
@SeeQuark die WM_SYSCOMMAND Nachricht bekommt nur das gerade aktive Fenster.
Hast du die SystemParametersInfo Funktion schon ausprobiert?
Du kannst die SystemParametersInfo Funktion verwenden um den Bildschirmschoner zu deaktivieren, oder die WM_SYSCOMMAND Windows Message abfangen und 1 zurückliefern.
Bin an C gebunden, bei C++ hätte ich einfach die STL Container verwendet.
Danke für eure Tipps.
Lg
Hallo Leute!
Ich suche eine Collection/Container Library für C. Diese sollte zumindest Listen(ArrayList/Vector) unterstützen, inklusive Funktionen für Sortieren und Suchen.
Besten Dank bereits im Voraus.
Lg
Das IsOpen Property wird nur überprüfen ob das Filehandle für den Serialport gültig ist. Und das ändert sich - nachdem du Open aufgerufen hast - nicht mehr.
Für derartige Fälle kannst du die WM_DEVICECHANGE Message abfangen und mit Hilfe der SetupAPI die vorhandenen Ports abfragen.
Warum verwendest du nicht die Attribute Serializable und NonSerialized und die Standardserialisierung von .Net?
Weil man das Attribute nicht bei Felder verwenden kann...
Das NonSerialized Attribute kann man doch gerade nur bei Feldern verwenden!?
Warum verwendest du nicht die Attribute Serializable und NonSerialized und die Standardserialisierung von .Net?
Sowohl die Klasse Form1 als auch die Klasse Modbus erzeugen eine FTDI Klasse. Somit versucht dein Programm vermutlich zweimal das USB Device zu öffnen, bzw. du vergisst in Modbus das Device zu öffnen => Error.
Lg
Sind nur im Compact Framework vorhanden. Macht im "normalen" FW auch keinen Sinn, da fast kein PC eine IR Schnittstelle hat.
Ich wollte damit verdeutlichen, dass die Geschwindigkeitsunterschiede beim Zugriff vernachlässigbar sofern vorhanden sind. Der wirkliche Geschwindigkeitsunterschied liegt beim Allokieren von Speicher. Wobei das Erzeugen eines Objektes am managed Heap wesentlich schneller ist, als bei traditionellen Speicherverwaltungen.
Der Stack ist doch aber garantiert im Cache enthalten. Beim Heap... eben nur "vermutlich häufig" ...
Ich wäre da vorsichtiger mit Äußerungen wie "garantiert", denn der Stack eines Threads kann defaultmäßig bis zu 1MB betragen somit bezweifle ich stark, das der ganze Stack im Cache liegt. Ich gehe zwar auch davon aus, dass mindestens der aktuelle Stackframe im Cache liegt, allerdings dürfte - wie bereits gesagt - auch der managed heap relativ gute Eigenschaften bezüglich Cache besitzen.
@Instruktion-unterschied:
Lokale Structs liegen zwar auf dem Stack, sobald du allerdings dieses struct an eine Funktion übergeben willst, übergibst du meistens einen Pointer, somit sind deine tollen Eigenschaften dahin. Auch für den Fall dass du die struct per value übergibst musst du diese erst kopieren, was auch wieder Performance kostet.
Da kann also garnix clever vom compiler "reingestrickt" werden.
Ich habe auch nie gesagt, dass es nur am Compiler liegt. Es kommt auf die CPU-Architektur, die Aufrufkonventionen, die Verwendung der Variablen durch den Programmierer(passing by reference) und natürlich auch auf den Compiler an, denn eventuell wird der Rückgabewert von new() nur in einem Register gespeichert und nicht am Stack, sodass die weitere Indirektionsstufe entfällt.
Kurz gesagt, der Geschwindigkeitsunterschied zwischen Stack und Heap ist beim Zugriff vernachlässigbar und kann auch nicht so allgemein beantwortet werden.
Lg
Hi zommi!
Diese Argumente sind aber sehr weit hergeholt. Denn der managed Heap eines .Net Programmes besitzt ebenfalls gewisse Lokalitätseigenschaften und wird vermutlich häufig im CPU-Cache liegen. Auch der Zugriff auf die Variablen selber ist vernachlässigbar, denn wie der Compiler schlussendlich die Variablen lädt hängt von vielen Parametern ab und lässt sich so nicht verallgemeinern.
Der Geschwindigkeitsunterschied hängt vielmehr davon ab, wie der Speicher allokiert wird.
Denn um n Bytes auf dem Stack zu reservieren reicht eine simple Subtraktion. Um Speicherplatz auf dem Heap zu reservieren müssen je nach Implementierung bei traditionellen Speicherverwaltungen(malloc/free) eine Freelists durchlaufen, und unter Umständen Speicherblöcke gesplittet oder vereinigt werden, was wesentlich mehr Zeit erfordert.
Ich hab aber das Problem, das ich mehrere enums habe!
Wo ist das Problem, die Erweiterungsmethode funktioniert mit beliegigen Enumtypen.
und weiters habe ich verschiedene Methoden, wo ich den Base-enum übergeben möchte.
Das geht halt nicht!
Enums sind im Prinzip nur Integers, ohne Vererbung, Interfaces, etc.
Damit kannst du Enumwerten einen String zuweisen und über MyStrings.String1.GetDisplayName() abfragen.
public enum MyStrings {
[System.ComponentModel.Description("My String 1")]
String1,
[System.ComponentModel.Description("My String 2")],
String2,
[System.ComponentModel.Description("My String 3")],
String3
}
public static class MyEnumExtensions {
public static string GetDisplayName(this Enum enumeration) {
Type t = enumeration.GetType();
MemberInfo[] info = t.GetMember(enumeration.ToString());
if (info.Length > 0) {
object[] attributes = info[0].GetCustomAttributes(typeof(System.ComponentModel.DescriptionAttribute), false);
if (attributes.Length > 0) {
return ((EnumDescription) attributes[0]).Description;
}
}
return enumeration.ToString();
}
}
C# unterstützt natürlich schon immer protected internal, das ist gleich bedeutend mit CLR: Family-and-Assembly.
protected internal entspricht Family-or-Assembly, da sowohl abgeleitete Typen in beliebigen Assemblies, sowie Typen in der gleichen Assembly auf diesen Member zugreifen können.
Ich kenne XNA jetzt nicht, aber eine Spiegelung ist eine Skalierung um den Faktor -1 für die x- bzw y-Achse, je nachdem ob horizontal oder vertikal gespiegelt werden soll.
Lg
Vermutlich, du kannst aber versuchen, ob du die Scannersoftware umkonfigurieren kannst.
static readonly PointF[] points = new PointF[] {
new PointF(0.0F, 0.0F),
new PointF(10.0F, 0.5F),
new PointF(20.0F, 1.0F),
new PointF(30.0F, 1.4F),
new PointF(40.0F, 1.0F),
new PointF(50.0F, 0.5F),
new PointF(60.0F, 0.0F),
new PointF(70.0F, -0.5F),
new PointF(80.0F, -1.0F),
new PointF(90.0F, -1.4F)
};
protected override void OnPaint(PaintEventArgs e) {
Graphics g = e.Graphics;
g.Clear(BackColor);
g.DrawLine(Pens.Black, new Point(0, 400), new Point(400, 400));
g.TranslateTransform(0.0F, 400.0F);
g.ScaleTransform(1.0F, -(800.0F / 1.4F / 2.0F));
g.DrawLines(Pens.Red, points);
}
Du musst deinen Werten halt x-Koordinaten zuweisen (hier 0, 10, 20, ...).
Einfach und schnell.
Gar nicht, nimm eine ReadOnlyCollection<T>.
Hallo IgG!
Sehr komisch, da die Tags eigentlich sehr einfach zu finden sind. Du kannst mir gerne ein solches .mp3 File schicken und ich werde den Fehler beheben.
Lg,
Georg
Eventuell falsches ImageFormat angegeben?