Hallo Mandy,

über die Kommandozeile kannst du dies mit "net use ..." machen.
Vielleicht kannst du mit deiner Suche da ansetzten.

Grüße

Hallo,

ich verstehe dein Problem so, dass du die Dateien nicht löschen kannst, weil sie durch dein Programm geöffnet sind?!

Wenn ja, dann versuche anstatt Image.FromFile die Methode Image.FromStream zu verwenden, in Kombination mit einem FileStream den du innerhalb eines using-Blockes verwendest. So sollten alle Dateien sofort wieder frei sein.

Grüße

Wenn die Kanäle so kommen, dann ist es halt so.

Zu deinem Problem:
Das Problem ist relativ simpel:
Die Dispatcher-Klasse regelt die Umleitung in den GUI Thread. Die Klasse Window erbt von DispatcherObject die Property "Dispatcher" vom Typ Dispatcher.

Ich rufe in meinem Code diese Property ab. Da du aber Dispatcher.CurrentDispatcher aufrufst interpretiert der Compiler dies als Aufruf der statischen Property Klasse Dispatcher.

if (!Dispatcher.CheckAccess()) vs
if (!Dispatcher.CurrentDispatcher.CheckAccess())

Und da du den Dispatcher für den momentanen Thread holst ist es logisch, dass auch kein Umleiten nötig ist, es ist ja der selbe Thread 😉

if (!this.Dispatcher.CheckAccess()) ist wohl die bessere, da eindeutigere, Schreibweise in diesem Fall.

Siehe Fzelle: Die Methoden nicht als statisch deklarieren.

grüße

Hallo greenpepper,

1.

writeableBitmap.Dispatcher.Invoke(new Action<byte[]>(UpdateImageData), pixels);

Den Invoke würde ich weglassen und die Methode direkt aufrufen, denn diese schaut selbst nach ob ein Invoke nötig ist oder nicht (doppelt gemoppelt).

2.
Du schreibst die Farbkanäle getrennt. Es ist auf jeden Fall schneller wenn du ein passendes PixelFormat wählst und den gesammten Puffer mit einem Aufruf von WriteableBitmap.WritePixels kopierst. Falls du nur den AlphaKanal entfernen willst kannst du z.B. Bgr32 nehmen und dieser wird ignoriert.

grüße

Hallo greenpepper,

ich hoffe, dass dir dies weiterhilft:

        private void YourThreadProc(IntPtr dummyPtr)
        {
            if (!Dispatcher.CheckAccess())
            {
                Dispatcher.Invoke(new Action<IntPtr>(YourThreadProc), dummyPtr);
                return;
            }

            bitmap.Lock();
            byte[] data = new byte[bitmap.Format.BitsPerPixel / 8 * bitmap.PixelWidth];
            Random rand = new Random();
            for (int i = 0; i < bitmap.PixelHeight; i++)
            {
                rand.NextBytes(data);
                IntPtr ptr = bitmap.BackBuffer + (i * bitmap.BackBufferStride);
                Marshal.Copy(data, 0, ptr, data.Length);
            }
            bitmap.AddDirtyRect(new Int32Rect(0, 0, bitmap.PixelWidth, bitmap.PixelHeight));
            bitmap.Unlock();
        }

grüße

Hallo hsg,

verwende diese Signatur:

unsafe public void CopyField(string cSource, byte* cDest, int length)

und übergib ebenfalls die Länge des (fixed size) Arrays.
Den Pointer wie ein normales .NET Array indizieren und auf die maximale Länge achten.

Grüße spooky

Hallo,

definiere void** entweder als "ref IntPtr" wenn der Parameter in/out ist oder als "out IntPtr" wenn er nur out ist.

Als Beispiel:

bool getList(out IntPtr address, ...);
void useList(IntPtr address, ...);

....
IntPtr address = InPtr.Zero;
if (getList(out address, ...))
  useList(address);
...

Grüße

spooky

Hallo Joseph,

[DllImport("pa_dde.dll", CharSet=CharSet.Auto)]
unsafe internal extern static bool Request([MarshalAs(UnmanagedType.LPTStr)] string Variable, [MarshalAs(UnmanagedType.LPTStr)] ref string ReturnStr);

Schau dir den Header der Funktion an und deklariere diese dann mit dem passenden CharSet (anstatt Auto); dann kannst du die MarshalAs-Attribute weglassen.

z.B:

[DllImport("pa_dde.dll", CharSet=CharSet.Unicode)]
internal extern static bool Request(string variable, StringBuilder returnString);

Der Rückgabe-String in Form eines in/out-Parameters ohne weiteren Längen-Parameter ist merkwürdig. Vermutlich gibt es eine vordefinierte Länge (siehe Header/Dokumentation). Benutze anstatt eines 'ref Strings' einen StringBuilder, der mit der benötigten Länge (Capacity) initialisiert wurde und übergib diesen by value.
Nach dem Aufruf kannst du dir den String mit .ToString() geben lassen; schreibe dir eine Wrapper-Funktion.

Deine Abstürze werden vermutlich falsches Marshalling sein, die den Heap oder Stack auf irgend eine Weise corrupten, wenn du zb. einen zu kurzen Buffer übergibst und über den allokierten Speicher hinaus schreibst.

Hallo Joseph,

der Artikel Calling Win32 DLLs in C# with P/Invoke könnte dir als Einstieg dienen. Besonders der Abschnitt über Text Marshalling.

Grüße spooky

Das beschriebene Problem ist doch, dass er immer in den default block springt und nicht, dass er den switch block optimiert.

Der Code aus dem Startpost funktioniert ohne Probleme.
Wenn du ToLower() schon versucht hast, warum hast du diese (wohl zum funktionieren essentielle Zeile) wieder gelöscht?

Hallo Lumbra,

Groß-/Kleinschreibung ggf?

spooky

Hallo,

ich verwende zum Beispiel Code Contracts. Die kompilierten Assemblies werden dabei umgeschrieben was dazu führt, dass die angezeigten Zeilen mit den tatsächlichen manchmal nicht übereinstimmen.
Vielleicht ist es in deinem Fall ähnlich?

spooky

Hallo Alex,

dies sollte dir weiterhelfen:

MemberInfo.GetCustomAttributes()

Grüße

Hallo DNAofDeath,

ist die "SQLite.Interop.dll" ebenfalls vorhanden? Hast du die Exception bis auf die Root-Exception (.InnerException Property rekursiv) durchsucht? Was sagt diese?

spooky

Hallo HerrOli,

die Klasse "Person" muss public sein.

spooky

Hallo Regenwurm,

du musst die Größe nur angeben, wenn du die Struct größer machen willst als die von dir deklarierten Member.

spooky

Hallo,

dieses Snippet sollte funktionieren (kleiner fix incl):

public static object ByteArrayToStruct(byte[] array, int offset, Type structType)
{
    if (array == null)
        throw new ArgumentNullException("array");

    if (structType == null)
        throw new ArgumentNullException("structType");

    if (!structType.IsValueType)
        throw new ArgumentException("structType");

    int size = Marshal.SizeOf(structType);

    if (array.Length < size)
        throw new ArgumentException("array");

    if ((offset < 0) || (offset + size > array.Length))
        throw new ArgumentOutOfRangeException("offset");

    object structure;
    GCHandle arrayHandle = GCHandle.Alloc(array, GCHandleType.Pinned);
    try
    {
        IntPtr ptr = arrayHandle.AddrOfPinnedObject();
        ptr += offset;
        structure = Marshal.PtrToStructure(arrayHandle.AddrOfPinnedObject(), structType);
    }
    finally
    {
        arrayHandle.Free();
    }
    return structure;
}

public static byte[] StructToByteArray(object structure)
{
    if (structure == null)
        throw new ArgumentNullException("structure");

    Type structType = structure.GetType();

    if (!structType.IsValueType)
        throw new ArgumentException("structure");

    int size = Marshal.SizeOf(structType);

    byte[] array = new byte[size];
    GCHandle arrayHandle = GCHandle.Alloc(array, GCHandleType.Pinned);
    try
    {
        IntPtr ptr = arrayHandle.AddrOfPinnedObject();
        Marshal.StructureToPtr(structure, ptr, false);
    }
    finally
    {
        arrayHandle.Free();
    }
    return array;
}

Grüße

spooky

Hallo Regenwurm,

diese Version sollte funktionieren:

static object ByteArrayToStruct(byte[] array, int offset, Type structType)
{
    if (array == null)
        throw new ArgumentNullException("array");

    if (!structType.IsValueType)
        throw new ArgumentException("structType");

    int size = Marshal.SizeOf(structType);

    if ((offset < 0) || (offset + size > array.Length))
        throw new ArgumentOutOfRangeException("offset");

    object structure;
    GCHandle structHandle = GCHandle.Alloc(array, GCHandleType.Pinned);
    try
    {
        IntPtr ptr = structHandle.AddrOfPinnedObject();
        ptr += offset;
        structure = Marshal.PtrToStructure(structHandle.AddrOfPinnedObject(), structType);
    }
    finally
    {
        structHandle.Free();
    }
    return structure;
}

spooky

Hallo,

da die Assembly selbst vorhanden ist, wird es wohl an einer ihrer Abhängigkeiten liegen. Versuche die InnerException Property der geworfenen Exception abzufragen um genauere Informationen zu erhalten.

spooky

Hallo,

am leichtesten sollte es sein, wenn du alle Nummern in eine Liste (List<int>) packst.
Danach schmeisst du solange einen Eintrag raus bis nurnoch einer vorhanden ist. Um den Richtigen zu ermitteln sollte index = liste.Count % Silben reichen.

Grüße

Hallo Fresh0razoR,

der Unterschied liegt darin, dass du in C++ Klassen wie Structs verwenden kannst:

Car mycar = Car();           // Variante 2

oder du kannst sie auf dem Heap erzeugen und so Polymorpie nutzen:

Car* mycar = new Car(); // Variante 1

Dies ist in C# nicht möglich. Structs werden immer auf dem Stack und Klassen immer auf dem Heap erzeugt (dabei verwenden beide Initialisierungen das new Schlüsselwort!).

spooky

Hallo,

auf den ersten Blick würde ich folgendes anmerken:Ein C++ long ist in C# ein int. Verwende für den Typen void IntPtr und nicht IntPtr[]. Verwende diesen Zeiger dann wie er in C++ gedacht war.

spooky

Hallo,

du kannst auch die WaitForExit-Überladung verwenden, die einen TimeOut annimmt (hast du vermutlich übersehen):

public static int StartProgram(string fileName, string arguments, int timeout)
{
    Process process = Process.Start(fileName, arguments);
    process.WaitForExit(timeout);
    process.Refresh();
    if (!process.HasExited)
    {
        process.Kill();
        return -1;
    }
    return process.ExitCode;
}

spooky

Hallo,

im Beispiel-Code wurde eine importierte Win32 Funktion verwendet (diese steht oben auf der verlinkten Seite).

Erstelle folgende Klasse in deinem Projekt:

internal static class NativeMethods
{
[DllImport("user32.dll")]
[return: MarshalAs(UnmanagedType.Bool)]
internal static extern bool GetKeyboardState(byte [] lpKeyState);
}

Ggf musst du noch auf Namespaces aufpassen.
Zu beachten ist, dass das zu übergebende Array 256 bytes groß sein muss; kannst du ggf nach durch eine Wrapperfunktion in der statischen Klasse sicherstellen.

spooky

Hallo,

um einen Ordner in C:\Users erstellen zu können brauchst der Prozess Administratorenrechte. Ohne diese bekommst du eine UnauthorizedAccessException.

spooky

Hi,

du kannst die CPU-Zeit nur berechnen indem du diese innerhalb einer Zeitspanne betrachtest, alle 1000ms über ein Event zB. Dabei brauchst du "PercentProcessorTime" und "TimeStamp_Sys100NS", wobei die Formel
(cpu2-cpu1)/(time2-time1) ist.

In dem Beispiel wird das noch mit 100 multipliziert. Das Ganze muss man, so vermute ich, noch durch die Anzahl der CPU-Kerne dividieren (Environment.ProcessorCount); zumindest waren die Werte dann plausibel.

spooky

Hallo ddr2,

ich habe für ein Projekt zum Messen von CPU Zeit die Win32-Klasse Win32_PerfFormattedData_PerfProc_Process verwendet.
Dort kannst du die Process-IDs und auch den Parent-Prozess auslesen, jedoch musst du die CPU-Zeiten wohl manuell berechnen.

Für die Verwendung musst du einen Verweis auf System.Management hinzufügen.

            ManagementObjectSearcher searcher = new ManagementObjectSearcher(
                @"Select Name, PercentProcessorTime, IDProcess, CreatingProcessID from Win32_PerfRawData_PerfProc_Process");

            foreach (var obj in searcher.Get())
            {
                Console.WriteLine("{0} {1} {2} {3}", obj["Name"], obj["PercentProcessorTime"], obj["IDProcess"], obj["CreatingProcessID"]);
            }   

Vielleicht hilft dir das weiter.

Grüße,
spooky

Hallo,

des Weiteren string verwenden anstatt StringBuilder und CharSet von Auto auf Ansi.

spooky

Hallo,

ich würde die Struct so deklarieren:

    [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Ansi, Pack = 1)]
    public struct SenderType
    {
        [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 50)]
        string name;
        short SenderId;
    }

Der Marshaller übernimmt das umwandeln in das inline Array und die Konvertierung von Unicode nach Ansi und du kannst trotzdem wie gewohnt einen string verwenden.

Nach der Änderung sollte es auch mit der Verwendung von ref klappen.

spooky

Hi,

ab .Net 4 (glaube ich) verfügt der Typ IntPtr auch über den IntPtr +(IntPtr,int) Operator. Damit würde die Verwendung von .ToInt64() wegfallen.

spooky

Ich weiss auf jeden Fall, dass Du einmal den Stringbuilder für den Rückgabewert nutzen musst, einen einfachen String für den Übergabeparameter.

Das ist Unsinn. StringBuilder dient bei Plattformaufrufen als beschreibbarer Puffer. Diesen Methoden übergibt man den StringBuilder + dessen Kapazität.
Wenn du eine konstante Zeichenkette als Parameter übergibst oder als Rückgabewert bekommst kann dieser als string deklariert werden.

Beispiel:

int WINAPI GetWindowText(__in HWND hWnd, __out LPTSTR lpString, __in int MaxCount);

wird zu:

int GetWindowText(IntPtr hWnd, StringBuilder lpString, int MaxCount);

wohingegen

BOOL WINAPI SetWindowText(__in HWND hWnd, __in_opt LPCTSTR lpString);

zu

bool SetWindowText(IntPtr hWnd, string lpString);

wird.

Es kommt auf die Verwendung des Parameters an, welche man der Dokumentation entnehmen muss.

Der Artikel Marshalling zwischen verwaltetem und nicht verwaltetem Code geht auf das ganze Thema etwas detaillierter ein.

Hallo,

ich habe den von dir verwendeten Code zur Konvertierung von Bitmap nach BitmapSource angeschaut. Dabei verwendest du den Zwischenschritt über ein hBitmap. Dieses hBitmap ist jedoch ein Handle, das nicht vom GC freigeben wird, siehe MSDN.

Dieses kleine Programm sollte das Problem und dessen Lösung erläutern:

using System;
using System.Drawing;
using System.Windows;
using System.Windows.Interop;
using System.Windows.Media.Imaging;
using System.Runtime.InteropServices;

namespace ConsoleApplication1
{
    class Program
    {
        static void Main(string[] args)
        {
            Bitmap bitmap = new Bitmap(@"c:\Users\Public\Pictures\Sample Pictures\Chrysanthemum.jpg");
            int i = 0;
            while (true)
            {
                IntPtr hBitmap = bitmap.GetHbitmap();
                var options = System.Windows.Media.Imaging.BitmapSizeOptions.FromWidthAndHeight(bitmap.Width, bitmap.Height);
                BitmapSource bitmapSource = Imaging.CreateBitmapSourceFromHBitmap(hBitmap, IntPtr.Zero, new Int32Rect(0, 0, bitmap.Width, bitmap.Height), options);
                //DeleteObject(hBitmap);
                if (++i == 10)
                {
                    GC.Collect(GC.MaxGeneration, GCCollectionMode.Forced);
                    GC.WaitForPendingFinalizers();
                    Console.WriteLine("Memory used: {0}", Environment.WorkingSet);
                    i = 0;
                }
            }
        }

        [DllImport("gdi32.dll")]
        public static extern bool DeleteObject(IntPtr hObject);
    }
}

Durch das Freigeben des Handles wird das Memoryleak geschlossen.

spooky

Hallo,

nachdem du den Verweis auf die COM dll hinzugefügt hast, musst du die Eigenschaften dieses öffnen und dort das Einbetten deaktivieren.

spooky

Hallo,

ich habe mal die Methode Clone wie von MrSparkle genannt versucht, und diese funktionierte bei mir ohne Probleme (8bppindexed).

public static Bitmap Clone(Bitmap bitmap)
{
    if (bitmap == null)
        throw new ArgumentNullException("bitmap");
    Rectangle rect = new Rectangle(0, 0, bitmap.Width, bitmap.Height);
    return bitmap.Clone(rect, bitmap.PixelFormat);
}

Sollte diese trotzdem nicht funktionieren, kannst du die Daten auch manuell klonen:

public static Bitmap Clone2(Bitmap bitmap)
{
    if (bitmap == null)
        throw new ArgumentNullException("bitmap");

    Bitmap clone;
    Rectangle rect = new Rectangle(0, 0, bitmap.Width, bitmap.Height);
    BitmapData bmpData = bitmap.LockBits(rect, ImageLockMode.ReadOnly, bitmap.PixelFormat);
    try
    {
        clone = new Bitmap(bmpData.Width, bmpData.Height, bmpData.Stride, bmpData.PixelFormat, bmpData.Scan0);
    }
    finally
    {
        bitmap.UnlockBits(bmpData);
    }
    clone.Palette = bitmap.Palette;
    return clone;
}

Ich hoffe das hilft dir weiter zum Thema klonen.

Warum das manuelle Kopieren von dir nicht funktioniert liegt am Layout der Farbstruct. Diese ist nicht ARGB sondern BGRA (siehe RGBQUAD):

typedef struct tagRGBQUAD { 
  BYTE rgbBlue;
  BYTE rgbGreen;
  BYTE rgbRed;
  BYTE rgbReserved;
} RGBQUAD;

Grüße

spooky

Hallo,

man sollte Dequeue noch so erweitern, dass vor dem Verlassen der Methode das zurückgegebene Element aus der Datenstruktur entfernt wird:

    ...
    item = current.next.item;
    current.next.item = default(T);
    return true;
}

Bei Dequeue wird die Verkettete Liste um eine Element verschoben (effektiv: last wird zu last.next). Dabei wird diese Node zum neuen "Anker" der Liste und wird NICHT vom GC abgeräumt - auch nicht das darin enthaltene Element.

Grüße

spooky

Hallo,

der optionale Parameter ist nur dann optional, wenn du weder ihn, noch Parameter rechts von ihm angibst. Da du den Paramter "Zusaetzliches" angibst, musst du auch "JaNein" angeben (in vb kann man glaube ich, auch optionale Parameter in der Mitte weglassen).
Was funktionieren würde, wäre gar keinen Parameter anzugeben.

spooky

Hallo,

etwas zu deiner Klasse selbst ...

public static class EqualsExtensions
{
	public static bool EqualsOneOf(this object first, params object[] others)
	{
		return others.Any(o => Object.Equals(first, o));
	}

	public static bool EqualsOneOf<T>(this IEquatable<T> first, params T[] others)
	{
		if (Object.ReferenceEquals(first, null))
			return others.Any(o => Object.ReferenceEquals(o, null));

		return others.Any(o => first.Equals(o));
	}
}

Wäre diese Implementierung nicht "korrekter"? Die Methode soll schauen ob "first" zu einem der folgenden Objekte equivalent ist. Dies bedeut aber streng genommen nicht, dass diese auch IEquatable<T> implementieren, sondern nur vom Typen T sein müssen.

Spooky

Hallo,

ich hab das Projekt mal umgebaut. Die .dll muss nurnoch ins Ausgabe-Verzeichnis des .NET Projektes kopiert werden.

Spooky

PS: StringBuilder braucht man wenn man einen Buffer übergibt in den geschrieben werden soll. Diese Funktionen haben dann meistens noch einen Parameter, der die Bufferlänge angibt zb:
void FillMe(char * buffer, int length, ...);
->
void FillMe(StringBuilder b, int length, ...);

Wenn es um fixe Strings geht braucht man keinen StringBuilder anlegen.

edit:
Der .NET Typ DateTime und der C++ Typ time_t sind wohl doch nicht kompatibel, daher musst du wohl einen kompatiblen Typen suchen oder Hilfsmethoden implementieren.

DateTime ist intern ein .NET long. Der C++ Typ time_t (time.h), der intern ebenfalls ein 64bit Integer ist könnte dafür ggf verwerdendet werden. Time Beispiel

Wie zommi schon gesagt hat, ist char * der Typ den du verwenden solltest. Ggf kannst du auch wchar_t * (Unicode) nehmen:

#include <time.h>
LPCWSTR __stdcall Generate(LPCWSTR s1, LPCWSTR s2, LPCWSTR s3, int number, time_t time);

Hallo JunkyXL,

am besten gehst du so vor:

Neues Projekt anlegen (Visual C++ -> Win32-Projekt) mit Anwendungstyp "Dll". Andere Optionen lassen, wie sie sind.

In der erzeugten .cpp Datei kannst du nun zB eine Funktion so deklarieren:

// Gehört eigentlich in die .h Datei
extern "C"
{
	BOOL __declspec(dllexport) __stdcall CheckKey(const unsigned char *key);
}

BOOL __stdcall InternalHelper(const unsigned char *key);
// Ende .h Datei

// Kann von aussen aufgerufen
BOOL __stdcall CheckKey(const unsigned char *key) {
	return InternalHelper(key);
}

// Nur intern verwendbar
BOOL __stdcall InternalHelper(const unsigned char *key) {
	return FALSE;
}

Dabei ist zu beachten, dass Funktionen die mit __declspec(dllexport) deklariert sind, nach aussen exportiert werden (d.h. Hilfsmethoden ohne dieses Tag können auch von aussen nicht aufgerufen werden).

Spooky

IntPtr strData = new IntPtr(plstr.ToInt32() + 4);

sollte noch in

IntPtr strData = new IntPtr(unchecked(plstr.ToInt64() + 4));

geändert werden um auch unter 64bit zu funktionieren. Ggf könnte man die Offset Operation noch in eine sperate Methode mit Over-/Underflow Check auslagern.

Spooky

Ein etwas aufgemotzerer Ansatz ...

public class Reference<T> where T : struct
{
	[DebuggerBrowsable(DebuggerBrowsableState.Never)]
	protected T value;

	public Reference()
	{

	}

	public Reference(T value)
	{
		this.value = value;
	}

	public static implicit operator T(Reference<T> value)
	{
		return value.value;
	}

	public static implicit operator Reference<T>(T value)
	{
		return new Reference<T>(value);
	}

	public T Value
	{
		get { return value; }
		set { this.value = value; }
	}

	public override string ToString()
	{
		return value.ToString();
	}

	public override int GetHashCode()
	{
		return value.GetHashCode();
	}

	public override bool Equals(object obj)
	{
		return (obj is Reference<T>) && value.Equals(((Reference<T>)obj).value);
	}
}

Hallo,

deine Wrapper-Klasse ist genau richtig um aus einem Werttypen einen Referenztypen zu machen.
Nullable<T> macht aus einem Werttypen einen null-baren Typen, aber keinen Referenztyp.

Spooky

Hallo,

auch den Datentyp long solltest du genauer anschauen, da dieser normalerweile 4 byte groß ist, welches ein int in .NET wäre.

Spooky

Hallo,

System.Collections.BitArray sollte dem sehr nahe kommen.

Spooky

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

Hallo lord_fritte,

siehe Dokumentation:

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

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