Forenbeiträge von egrath Ingesamt 871 Beiträge
Hallo,
... und was steht in der Exception?
Grüsse,
Egon
Hallo,
1.) Also den bool m_Terminate habe ich eingebaut damit man im Thread eine Abbruchbedingung hat und diesen somit sauber beenden kann.
2.) Das "// Tue irgendwas" steht als Platzhalter für die eigentliche Arbeit die in deinem Fall alle 20 ms ausgeführt werden soll.
Grüsse,
Egon
Hallo,
wenn Du es über einen Thread machst und relativ fixe 20 ms brauchst (relativ deshalb weil dir unter Windows nichts garantiert 😉, dann solltest du mittels einer Stopwatch die Laufzeit des eigentlichen Codes messen und dann nur mehr die differenz zu 20ms warten.
using System;
using System.Threading;
using System.Diagnostics;
public class MyClass
{
private static bool m_Terminate = false;
public static void Main()
{
Thread processorThread = new Thread( new ThreadStart( ProcessThread ));
processorThread.Start();
Console.In.ReadLine();
m_Terminate = true;
processorThread.Join();
}
public static void ProcessThread()
{
Stopwatch sw = new Stopwatch();
while( ! m_Terminate )
{
sw.Reset();
sw.Start();
// Tue irgendetwas
sw.Stop();
if( sw.ElapsedMilliseconds < 20 )
{
Thread.Sleep( 20 - ( int ) sw.ElapsedMilliseconds );
}
}
}
}
Grüsse,
Egon
Hallo,
ich hatte die Aufgabenstellung dass ein Kunde kleinere Teile in einer unserer Applikationen selbst in C# customizen kann. Dafür habe ich einen sehr rudimentären und einfachen Scripting Host entwickelt, der Quellcodes zur Laufzeit übersetzt. Die im Quellcode enthaltene Klasse kommuniziert über Interfaces mit dem Host, der wiederum funktionalitäten der Applikation zur verfügung stellt.
Im Anhang findet Ihr die Kernimplementierung, vielleicht kann diese ja jemand von euch brauchen.
Grüsse,
Egon
Hallo,
das nächste auf das ich tippen würde wäre eine eventuell vorhandene Firewall und der Virenscanner. Eventuell werden irgendwelche Netzwerkports blockiert die VS für die IPC Kommunikation beim Debuggen braucht.
Schau mal in den entsprechenden Logfiles nach ob was drinnen steht.
Grüsse,
Egon
Hallo,
hast Du die Terminal Services unter den Diensten in der Systemsteuerung deaktiviert? VS braucht die nämlich zwingend zum Debuggen.
Grüsse,
Egon
Hallo,
ich habs jetzt nicht probiert - aber ich nehme mal stark an dass dabei eine Window Message gesendet wird. Schau dir mal die Messages an die dein Fenster empfängt.
Grüsse,
Egon
Hallo,
schau dir mal die ImageAnimator Klasse an. Ich glaube dass die das richtige für dich ist.
Grüsse,
Egon
Hallo,
Stichwort: TransparencyKey
(Setze z.B. den Hintergrund deines Forms auf eine Farbe und den TransparencyKey auch auf diese - dann wird's Transparent 🙂
Grüsse,
Egon
Hallo,
müsste so funktionieren (Code aus Google kopiert 😉:
ManagementObjectSearcher searcher = new ManagementObjectSearcher("SELECT *
FROM Win32_ConnectionShare");
foreach (ManagementObject connectionShare in searcher.Get())
{
// Win32_Share
string antecedent = connectionShare["Antecedent"].ToString();
Console.WriteLine("Antecedent: " + antecedent);
ManagementObject share = new ManagementObject(antecedent);
// Win32_ServerConnection
string dependant = connectionShare["Dependent"].ToString();
Console.WriteLine("Dependant: " + dependant);
ManagementObject connection = new ManagementObject(dependant);
Console.WriteLine(share["Name"].ToString());
if (connection != null && connection["Name"] != null)
Console.WriteLine(connection["Name"].ToString());
Console.WriteLine("\n");
}
Grüsse,
Egon
Hallo,
ich stelle mir gerade die Frage bezüglich des Designs von folgendem Szenario:
1.) Eine Konsolenapplikation welche über Sockets Netzwerkanfragen entgegenennimmt und beantwortet
2.) In einem Thread läuft ein User-Input Loop um diverse einstellungen zur Laufzeit vornehmen zu können
3.) In einem anderen Thread läuft der Socket Server der die anfragen entgegennimmt und ...
4.) ... einen weiteren Thread startet der dann die Anfrage beantwortet.
Der User kann sich mittels eines Befehls Statistiken über die abgearbeiteten Netzwerkanfragen anzeigen lassen. Da der User Input Thread allerdings keine Ahnung vom Thread hat, der die Anfragen abarbeitet: Wie sollte man diese statistischen Daten am besten übermitteln? (Ich benötige als Information nur wieviele Anfragen positiv abgearbeitet wurden)
Zwei Lösungsansätze die mir in den sinn kommen und möglich wären:
1.) Einen Delegaten erstellen der bis zum abarbeitenden Thread weitergereicht wird und eine Methode im User-Input Thread aufruft und dort die statistischen Informationen ablegt.
2.) Ein Singleton auf welches beide Threads zugreifen. Der abarbeitende Thread um die statistischen Informationen zu aktualisieren, der User-Input Thread um sich diese zu holen und darzustellen.
3.) Ein statisches Feld in welchem die statistischen Informationen gespeichert sind.
Methode 1 gefällt mir vom Design her nicht und Methode 3 finde ich sowieso äusserst unelegant -> Tendenz meinerseits daher zum Singleton.
... oder gibt es eine andere "Best Practice" wie ich das realisieren könnte?
Danke und Grüsse,
Egon
Hallo,
Schlagwörter hierfür sind: Endianess, Big-Endian, Little-Endian
Grüsse,
Egon
Hallo,
auch wärmstens zu empfehlen ist das Buch "CLR via C#" aus dem MSPress verlag. Dort gehts genau um solche Internas wie die von dir erwähnten.
Grüsse,
Egon
Hallo,
wenn Du mit VS2005 1.1er Assemblys erstellen willst, benutze am besten MSBee. Gibt hier im Forum einige Beiträge dazu.
Grüsse,
Egon
Hallo,
using System;
using System.Management;
using System.Windows.Forms;
namespace WMISample
{
public class MyWMIQuery
{
public static void Main()
{
try
{
ManagementObjectSearcher searcher =
new ManagementObjectSearcher("root\\CIMV2",
"SELECT * FROM Win32_OperatingSystem");
foreach (ManagementObject queryObj in searcher.Get())
{
Console.WriteLine("-----------------------------------");
Console.WriteLine("Win32_OperatingSystem instance");
Console.WriteLine("-----------------------------------");
Console.WriteLine("TotalVisibleMemorySize: {0}", queryObj["TotalVisibleMemorySize"]);
}
}
catch (ManagementException e)
{
MessageBox.Show("An error occurred while querying for WMI data: " + e.Message);
}
}
}
}
Schau dir mal den WMI Code Generator an, der dürfte was für dich sein:
http://www.microsoft.com/downloads/details.aspx?FamilyID=2cc30a64-ea15-4661-8da4-55bbc145c30e&displaylang=en
Grüsse,
Egon
Hallo,
du kannst aber schauen ob deine Applikation unter Mono läuft - denn das ist unter Windows NT 4.0 funktionsfähig.
Grüsse,
Egon
... und weil wir grad dabei sind: Die Express Edition's sind auch auf Deutsch verfügbar:
Grüsse,
Egon
merkwürdig, dass er plötzlich in der dritten person von sich spricht 😉
Ich vermute mal stark dass das Bild für die Visualisation-Engine zu viel war. Aufgrund einer unsauberen Implementierung dieser wurde eine nicht behandelte Exception ausgelöst, die bestimmte andere Module in mitleidenschaft gezogen hat - wie in diesem Fall das Modul "ICH-Bezug" 🙂
Grüsse,
Egon
Hallo,
warum machst Du nicht einen Screenshot in der aktuellen Auflösung und skalierst diesen dann auf die gewünschte Auflösung?
Grüsse,
Egon
Hallo,
habe mal ein kurzes Beispiel zusammengehackt, welches zeigt:* Einen Socket Server
- Einen Socket Client
- Wie man am Client ein Objekt serialisiert, über den NetworkStream schickt und am Server wieder deserialisiert
Wie gesagt, nur kurz zusammengehackt, also kein ausgefeilter Code, aber sollte grundlegend zeigen wie man das implementieren könnte.
Grüsse,
Egon
Hallo,
die Funktion "GetPixel" aus der Win32 API ist dein Freund. In Kombination mit GetDesktopWindow und GetWindowDC müsstest Du an dein gewünschtes ziel kommen.
Die entsprechenden signaturen findest Du unter www.pinvoke.net
Grüsse,
Egon
... zumindest solange es keine Hardware gibt, die direkt managed Code ausführen kann.
Genau das ist etwas bei dem ich mir ziemlich sicher bin, dass es das in den nächsten Jahren geben wird. Java hat's vorgemacht und die Entwickler von Embedded Prozessoren sind auf den Zug aufgesprungen und haben die Bytecode Execution direkt in den Prozessor gepackt.
Gerade da Microsoft ja im Embedded Bereich (mit Windows Mobile, Windows Automotive) relativ stark vertreten ist wird sich da sicherlich einiges tun.
Grüsse,
Egon
Hallo,
lt. Link (MSDN Forum) dürfen die Icons anscheinend nur innerhalb von Resourcen in Binaries mitgeliefert werden die mit einer Vollversion erstellt wurden.
Es wird aber den Express Usern empfohlen zum "testen" der Icons die 180 Tage Trial zu laden (und dann natürlich zu kaufen)
Grüsse,
Egon
Hallo,
wenn Du mit einem BinaryReader liest dann ist es grundsätzlich irrelevant welches Encoding du setzt, da du ja eh nur 1:1 die Bytes bekommst die im File vorhanden sind (wenn Du ReadByte(s) benutzt). Zeig mal etwas Code und erkläre was Du mit den eingelesenen Daten machen möchtest. Da Du geschrieben hast dass die Daten im File verschlüsselt sind, nehme ich an, dass Du diese entschlüsseln willst?
Grüsse,
Egon
Hallo,
ich hab es noch nicht probiert, aber normalerweise sollte es reichen wenn Du die mit Mono erstellte Assembly unter Windows durch einen Obfuscator jagst. Wenn der keine wirklichen Krummen Sachen mit dem IL macht, dann kommt auch die Mono VM mit dem Code zurecht.
Grüsse,
Egon
/edit: Grad mit dem Dotfuscator bei einem grösseren Projekt versucht. Mit Mono kompilierte Assembly läuft auch nach dem Obfuskieren noch immer tadellos (Hab aber nicht die gesamte Funktionalität der Applikation getestet, sondern nur ob die noch läuft und ein paar kleine Sachen - auf jeden Fall solltest Du die Applikation nach dem Obfuskieren sehr gut testen)
Hallo,
für alle die noch kein VS2008 benutzen und es sich gerne mal ansehen würden bevor die Investition getätigt wird: Ab jetzt sind die 90-tagigen Testversionen (Englisch) verfügbar:
VS2008 Professional
VS2008 Team Suite
VS2008 Team Foundation Server
Viel Spass damit!
Grüsse,
Egon
Hallo,
eine einfache Google Suche (nach z.B: "VS2005 Keybinding Poster site:microsoft.com") hätte dich schnurstracks (1st Hit) auf folgende Seite gebracht:
Dort findet sich das gleiche für VS05
Grüsse,
Egon
Hallo,
natürlich gibt es wie überall Vor- und Nachteile einer solchen Sache:
Vorteile:* Man lernt auf jeden Fall viel wenn man die gesamten Protokolle selbst implementiert
- Der Server kann gezielt auf die eigenen Ansprüche getrimmt werden
Nachteile:* Eine saubere, standardkonforme Implementierung kann sehr Zeitaufwendig werden.
- Verfügbare Implementationen (Apache,IIS) sind schon sehr ausgereift, bieten einen hohen Funktionsumfang und sind mehr oder minder für Lau zu haben - warum also das Rad neu erfinden
Wenn es dir nur um's Lernen geht sicher ein interessantes Thema und einen versuch wert. Andernfalls würde ich persönlich die Finger davon lassen.
Grüsse,
Egon
Hallo,
Microsoft hat soeben ein Poster mit allen Keybindings für VS2008 veröffentlicht. Schaut nicht mal so schlecht aus wenn mans auf A3 ausdruckt und auf die Pinwand heftet 😉
Grüsse,
Egon
Hallo,
... obwohl ich dennoch der Meinung bin dass der übersichtlichkeit halber der Delegate verwendet werden sollte. Zu viel Compiler Magic macht den Code doch nur unlogischer (imho).
Grüsse,
Egon
Hallo svenson,
bah Betriebsblind. Ich benutze normalerweise die zweite von dir gezeigte Methode und hab schlicht und ergreifend nicht bemerkt dass ich den Reset vergessen hab.
Hoffe wirklich dass Mono bald nen Debugger bekommt 😉
Grüsse,
Egon
Hallo,
habe gerade ein interessantes Phänomen. Eine Klasse welche die Knoten eines Graphen verwaltet implementiert IEnumerator und IEnumerable damit ich über alle Knoten schnell iterieren kann.
Üblicherweise wird vor jedem Iterationsstart die Methode "public void Reset()" des IEnumerator Interfaces aufgerufen, welche dann den internen Positionszähler zurücksetzt. Nicht aber bei mir - wenn ich beispielsweise folgenden Code ausführe:
foreach( Node n in m_NodeManager )
{
if( n.Type == Node.NodeType.EndNode )
{
n.Type = Node.NodeType.IntermediateNode;
drawingArea.QueueDrawArea( n.Position.X -10, n.Position.Y -10, 20, 20 );
}
}
Dann findet keine Iteration über die Knoten statt (m_NodeManager ist vom Type "NodeManager", welcher die Interfaces implementiert).
Untenstehend der Source der NodeManager Klasse:
using System;
using System.Collections.Generic;
using System.Collections;
using System.Runtime.Serialization;
using System.Runtime.Serialization.Formatters.Binary;
using System.IO;
namespace egrath.test.graph
{
[Serializable]
public class NodeManager : IEnumerator, IEnumerable
{
private List<Node> m_Nodes;
public NodeManager()
{
m_Nodes = new List<Node>();
}
public bool AddNode( Node node )
{
if( ! m_Nodes.Contains( node ))
{
#if DEBUG
Console.Out.WriteLine( "[INFO]: Adding new Node: {0}", node );
#endif
m_Nodes.Add( node );
return true;
}
return false;
}
public Node GetNodeAtPosition( Gdk.Point pos )
{
foreach( Node n in m_Nodes )
{
if( pos.X >= ( n.Position.X -10 ) && pos.X <= ( n.Position.X +10 ) &&
pos.Y >= ( n.Position.Y -10 ) && pos.Y <= ( n.Position.Y +10 ))
{
return n;
}
}
return null;
}
public int Count
{
get { return m_Nodes.Count; }
}
public void CalculateShortestPath()
{
#if DEBUG
Console.Out.WriteLine( "[INFO]: Calculating Shortest path between start and end" );
#endif
}
public static NodeManager FromFile( string fileName )
{
Stream reader = ( new StreamReader( fileName ).BaseStream );
BinaryFormatter formatter = new BinaryFormatter();
NodeManager m = ( NodeManager ) formatter.Deserialize( reader );
reader.Close();
return m;
}
public static void ToFile( NodeManager instance, string fileName )
{
Stream writer = ( new StreamWriter( fileName ).BaseStream );
BinaryFormatter formatter = new BinaryFormatter();
formatter.Serialize( writer, instance );
writer.Close();
}
// Indexer
public Node this[int index]
{
get { return m_Nodes[index]; }
set { m_Nodes[index] = value; }
}
// IEnumerable Interface
public IEnumerator GetEnumerator()
{
return ( IEnumerator ) this;
}
// IEnumerator Interface
public int m_IEnumeratorIndex = -1;
public object Current
{
get { return m_Nodes[m_IEnumeratorIndex] as object; }
}
public bool MoveNext()
{
if( m_IEnumeratorIndex < ( m_Nodes.Count -1 ))
{
m_IEnumeratorIndex ++;
return true;
}
return false;
}
public void Reset()
{
m_IEnumeratorIndex = -1;
}
}
}
Irgendeiner ne Idee wo sich bei mir der Hund befindet?
Danke und Grüsse,
Egon
/edit: Wenn ich vor der foreach Schleife die Reset() Methode von m_NodeManager aufrufe, dann wird iteriert.
Hallo,
also ich persönlich handhabe es so:* Für Business Anwendungen die nicht so sonderlich auf grafischen Schnick-Schnack wert legen benutze ich Windows Forms. Die Annahme, dass Windows Forms durch das aufkommen von WPF obsolete geworden ist, ist eine Falschannahme welche vor einiger Zeit in einem MSDN Blog bestätigt wurde (Link für weiterführende Informationen)
- Für Endanwender Anwendungen die optisch ordentlich was hermachen sollen (z.B. so etwas wie iTunes, etc.) ist WPF gedacht. Aber auch hier meiner Meinung nach nur wenn es Sinn macht.
- Für Cross Platform Applikationen entweder Windows Forms oder GTK#
Grüsse,
Egon
Lustig zu lesen - aber hat doch einen gewissen Wahrheitsgehalt wenn man drüber nachdenkt.
Grüsse,
Egon
Hallo,
das kommt immer auf das einsatzgebiet drauf an. Wenn Du zur laufzeit gezwungen bist mit den Elementen innerhalb von (Array|Liste) herumzutun (Einfügen, Löschen, etc.) dann bist du mit einer List sicherlich besser aufgehoben. Wenn die Anzahl der Elemente relativ statisch ist, dann würde ich zu einem Array greifen.
Grüsse,
Egon
Hallo,
ich denke dass man es dein meisten Benutzern zumuten kann das .NET Framework 2.0 manuell herunterzuladen und zu installieren. Handelt es sich um ein größeres Projekt welches nicht als Download angeboten wird sondern einen anderen Weg zum Kunden findet, so ist es kein Problem dieses mit auf den Datenträger zu packen und vom Installer installieren zu lassen.
Denke also, es ist kein K.O. Kriterium für .NET Applikationen dass manche das 2.0er noch nicht installiert haben.
Grüsse,
Egon
Hallo,
korrekt, es wird so lange gewartet bis der lock frei ist und dann der Body ausgeführt.
Grüsse,
Egon
/edit: In deinem Beispiel wird natürlich nicht gewartet, da ja der Aufruf von add abgearbeitet wird und dann erst remove aufgrufen wird - wenn aber von mehreren Thread parallel zugegriffen wird, dann schon.
Hallo,
den Wrapper schreibst Du ja in C#. Nehmen wir an, du hast eine DLL welche die Funktion "void PrintSomething( char* text )" exportiert. Dann kannst Du mittels P/Invoke diese Funktion aufrufen:
Zuerst einmal deklarieren:
[DllImport( "MeineDll" )]
public static extern void PrintSomething( string text );
Und dann benutzen:
PrintSomething( "Hello, World!" );
Wenn es eine DLL ist welche viele Sachen exportierst die Du benötist, dann erstellst Du dir z.B. ein DLL Projekt in dem die entsprechenden P/Invoke's bekanntmachst und dir die entsprechenden Methoden rundherumschreibst (weil du bei jedem Aufruf z.b. noch etwas Logik dazubaust)
Grüsse,
Egon
Hallo,
im Prinzip ist es egal auf welchem Rechner Dumps analysiert werden. Wichtig ist nur, dass Du die entsprechenden Symbols hast die mit seiner Installation korrespondieren.
Grüsse,
Egon
Hallo,
ja MSBee ist ein Build Tool von Microsoft welchem Du als Parameter den Namen des Projekts mitgibst (und noch einige andere Parameter). Ich habe mir z.B. einen Batch Job geschrieben der so aussieht:
if "%1" equ "release" (
msbuild MedCalc.csproj /p:Configuration=Release /p:TargetFX1_1=true /p:CustomAfterMicrosoftCommonTargets="%ProgramFiles%\MSBuild\MSBee\MSBuildExtras.Fx1_1.CSharp.targets"
else (
msbuild MedCalc.csproj /p:TargetFX1_1=true /p:CustomAfterMicrosoftCommonTargets="%ProgramFiles%\MSBuild\MSBee\MSBuildExtras.Fx1_1.CSharp.targets"
)
Je nach dem ob ich den Batch Job mit "release" als Parameter aufrufe oder nicht bekomme ich ein Verzeichnis "bin\FX_1_1\Debug" oder bin\FX_1_1\Release" welche dann die mit 1.1 kompilierten Binaries enthalten.
Grüsse,
Egon
Hallo,
mir ist es vor einigen Jahren ähnlich gegangen - mit VS2003 erstellte Projekte für das 1.1er Framework mussten noch weitergewartet werden und mit dem 1.1er laufen - obwohl wir flächendeckend auf VS2005 umgestiegen sind.
Die Lösung ist hier MSBee - damit entwickelt man mit VS2005 und bevor man das Release an Kunden rausgibt kompiliert man die Solution per Hand mit MSBee und bekommt ne 1.1er Assembly raus (sofern man keine 2.0 spezifischen Spracherweiterungen oder Klassen benutzt hat).
Grüsse,
Egon
Hallo,
Zuerst mal zu DX und XNA:
DirectX wird soweit ich das mitbekommen habe in der jetzigen Form für .NET (Managed DirectX) nicht mehr weiterentwickelt. XNA ist die Platform die Microsoft für die Spielentwicklung unter .NET propagiert.
Da ich selbst nicht mit DX oder XNA entwickle, kann ich nur das wiedergeben was man so liest: DirectX hat mehr möglichkeiten als XNA, ist dafür aber auch komplexer in der Handhabung. Für "professionelle" 3D Anwendungen (also keine Spiele) ist XNA nicht geeignet. Wenn Du also etwas anderes ausser Spiele machen möchtest bist Du gezwungen einen der folgende Wege einzuschlagen:* Das sich nicht mehr weiterentwickelnde Managed DirectX benutzen
- OpenGL zu benutzen (TAO; gibt auch einige gute Tutorials dafür)
Jetzt zu Irrlicht:
Irrlicht wurde als komplette 3D Engine entworfen und nicht nur als Renderer. Es ist ursprünglich in C++ geschrieben, es gibt aber eine Managed Variante "Irrlicht.NET". Als Renderer kann entweder DirectX oder OpenGL verwendet werden. Da es sich um eine komplette Engine handelt, sind schon viele Dinge inkludiert die man ansonsten selbst ausprogrammieren müsste (oder 3rd Party Libraries benutzen müsste): Partikelsystem, usw..
Hoffe dass das von mir gegebene einigermassen zutrifft, wenn nicht bitte korrigieren.
Grüsse,
Egon
Hallo,
C64: North & South; Great Giana Sisters;
Amiga: Ein Spiel dessen Namen ich nicht mehr weiss. Es ging darum dass man mit einem Gleiter in einer 3D Arena rumfuhr und Gegner abballern musste. Schlichte Polygon 3D Grafik (Flat Shading). Monkey Island 1&2, Indiana Jones
SNES: natürlich Klassiker wie Zelda, Super Mario World, F-Zero und Super Probotector.
Saturn: Saturn Bomberman. Das einzige das ich auch heute noch gerne Spiele wenn Freunde auf Besuch kommen.
Grüsse,
Egon
Hallo,
mir is grad noch eine möglichkeit eingefallen - ob dir die in Bezug auf eleganz gefällt ist eine andere Sache: WebDAV
Du kannst ja WebDAV Folder als Laufwerk mappen. Implementiere eine eigenen WebDAV Server und behandle die Anfragen nach deinen Anforderungen. Voila - erledigt.
Ist meines erachtens zwar bei weitem nicht so elegant wie ein "richtiges" Filesystem, aber einfacher zu implementieren als die SMB/CIFS Lösung.
Grüsse,
Egon
/edit: WebDAV als Laufwerk einbinden: http://www.tu-harburg.de/rzt/webserver/WebDAV/Clients/WindowsClients.shtml
Das heißt doch dann aber im Umkehrschluss, dass der Monocompiler einen Bug hat, oder? Weil, da sich das Beispiel unter Mono kompilieren lässt, verletzt er doch die von Dir zitierte Passage, oder?
Hab den Thread grad entdeckt und muss sagen: Interessant. Aber: Als Mono'ler muss ich dazu sagen: It's not a Bug, it's a Feature!
Hallo,
also um native Operationen wirst Du sicherlich mal nicht umher kommen. Bin mir nicht sicher ob man für so etwas nicht sogar einen Kerneltreiber benötigt (oder ob es unter Windows so etwas wie Userland-FS unter Linux gibt).
Schau dir am besten mal an wie es andere Programme machen. TrueCrypt wäre ein beispiel dafür, da es genau so etwas macht und Open Source ist.
Grüsse,
Egon
Hallo,
das hört sich so an, als ob in deinem Paint Handler das Invalidierte Rect nicht korrekt aus dem BackBuffer rüberkopiert wird. Zeig uns mal etwas Code, dann können wir schauen ob wir was finden.
Grüsse,
Egon
Hallo,
da du vermutlich alle Bilder unkomprimiert im YUY2 Format kriegst, sollte dein erster schritt einmal sein dass Du versuchst die Bilder nach RGB zu wandeln und auf den Bildschirm zu kriegen - wenn Du das hast, dann ist die erste Hürde einmal genommen.
Im nächsten Schritt brauchst Du dann einen Encoder für MPEG4. Am einfachsten ist es, wenn du mittels P/Invoke auf die API eines Encoders zurückgreifst (z.B. XVid) - API's fürs Encoding nehmen im Normalfall RGB Images entgegen und spucken einen kodierten Stream wieder aus - für das war die übung oben 😉
http://www.fourcc.org/yuv.php
http://en.wikipedia.org/wiki/YUV
http://www.fourcc.org/fccyvrgb.php
Grüsse,
Egon
Hallo,
wenn chkdsk Fehler meldet und repariert - und beim nächsten Lauf nicht mehr ist das zum ersten schon mal ein gutes zeichen. Wenn du das allerdings öfters hast, dann würd ich mir mal sicherheitshalber eine neue Disk zulegen. Fehler sind bei NTFS eher selten und deuten auf einen HDD Defekt hin.
Grüsse,
Egon
Hallo Golo,
RoboCopy war früher nur im ResourceKit enthalten und hat gegenüber xcopy einen meines erachtens nach gravierenden Nachteil: Die Syntax ist komplexer (oder besser gesagt: man ist xcopy gewohnt).
z.B. kopieren eines Folders C:\Temp\ nach D:\Temp:
xcopy:
xcopy C:\temp* D:\temp*
robocopy:
robocopy C:\temp D:\temp . /LEV:1
Robocopy nimmt standardmässig alle unterverzeichnisse mit, wenn ich es nicht explizit angebe. Meines erachtens nach einfach etwas komplexer für einfache aufgaben.
Dafür muss man schon sagen dass RoboCopy extrem mächtig ist. Angefangen von Restartable Copy's, über die möglichkeiten ACL's mitzukopieren, etc.... es ist beinahe alles möglich was das Kopiererherz benötigt.
Ich benutze persönlich für das "schnell kopieren zwischendurch" immer noch xcopy, da ich nicht glaube dass es so schnell aus Windows verschwinden wird, auch wenn es als Deprecated gekennzeichnet ist. Für's kopieren in automatisiert ablaufenden Batch-Jobs verwende ich hingegen RoboCopy, da ich seine zuverlässigkeit (restart) schätze.
Grüsse
Egon
ps: Für alle die noch kein Vista haben (oder ResourceKit) und RoboCopy nicht kennen: Hier mal die Liste aller möglichen Optionen 😉
-------------------------------------------------------------------------------
ROBOCOPY :: Robust File Copy for Windows
-------------------------------------------------------------------------------
Started : Tue Jan 15 14:25:03 2008
Usage :: ROBOCOPY source destination [file [file]...] [options]
source :: Source Directory (drive:\path or \\server\share\path).
destination :: Destination Dir (drive:\path or \\server\share\path).
file :: File(s) to copy (names/wildcards: default is "*.*").
::
:: Copy options :
::
/S :: copy Subdirectories, but not empty ones.
/E :: copy subdirectories, including Empty ones.
/LEV:n :: only copy the top n LEVels of the source directory tree.
/Z :: copy files in restartable mode.
/B :: copy files in Backup mode.
/ZB :: use restartable mode; if access denied use Backup mode.
/EFSRAW :: copy all encrypted files in EFS RAW mode.
/COPY:copyflag[s] :: what to COPY for files (default is /COPY:DAT).
(copyflags : D=Data, A=Attributes, T=Timestamps).
(S=Security=NTFS ACLs, O=Owner info, U=aUditing info).
/DCOPY:T :: COPY Directory Timestamps.
/SEC :: copy files with SECurity (equivalent to /COPY:DATS).
/COPYALL :: COPY ALL file info (equivalent to /COPY:DATSOU).
/NOCOPY :: COPY NO file info (useful with /PURGE).
/SECFIX :: FIX file SECurity on all files, even skipped files.
/TIMFIX :: FIX file TIMes on all files, even skipped files.
/PURGE :: delete dest files/dirs that no longer exist in source.
/MIR :: MIRror a directory tree (equivalent to /E plus /PURGE).
/MOV :: MOVe files (delete from source after copying).
/MOVE :: MOVE files AND dirs (delete from source after copying).
/A+:[RASHCNET] :: add the given Attributes to copied files.
/A-:[RASHCNET] :: remove the given Attributes from copied files.
/CREATE :: CREATE directory tree and zero-length files only.
/FAT :: create destination files using 8.3 FAT file names only.
/256 :: turn off very long path (> 256 characters) support.
/MON:n :: MONitor source; run again when more than n changes seen.
/MOT:m :: MOnitor source; run again in m minutes Time, if changed.
/RH:hhmm-hhmm :: Run Hours - times when new copies may be started.
/PF :: check run hours on a Per File (not per pass) basis.
/IPG:n :: Inter-Packet Gap (ms), to free bandwidth on slow lines.
::
:: File Selection Options :
::
/A :: copy only files with the Archive attribute set.
/M :: copy only files with the Archive attribute and reset it.
/IA:[RASHCNETO] :: Include only files with any of the given Attributes set.
/XA:[RASHCNETO] :: eXclude files with any of the given Attributes set.
/XF file [file]... :: eXclude Files matching given names/paths/wildcards.
/XD dirs [dirs]... :: eXclude Directories matching given names/paths.
/XC :: eXclude Changed files.
/XN :: eXclude Newer files.
/XO :: eXclude Older files.
/XX :: eXclude eXtra files and directories.
/XL :: eXclude Lonely files and directories.
/IS :: Include Same files.
/IT :: Include Tweaked files.
/MAX:n :: MAXimum file size - exclude files bigger than n bytes.
/MIN:n :: MINimum file size - exclude files smaller than n bytes.
/MAXAGE:n :: MAXimum file AGE - exclude files older than n days/date.
/MINAGE:n :: MINimum file AGE - exclude files newer than n days/date.
/MAXLAD:n :: MAXimum Last Access Date - exclude files unused since n.
/MINLAD:n :: MINimum Last Access Date - exclude files used since n.
(If n < 1900 then n = n days, else n = YYYYMMDD date).
/XJ :: eXclude Junction points. (normally included by default).
/FFT :: assume FAT File Times (2-second granularity).
/DST :: compensate for one-hour DST time differences.
/XJD :: eXclude Junction points for Directories.
/XJF :: eXclude Junction points for Files.
::
:: Retry Options :
::
/R:n :: number of Retries on failed copies: default 1 million.
/W:n :: Wait time between retries: default is 30 seconds.
/REG :: Save /R:n and /W:n in the Registry as default settings.
/TBD :: wait for sharenames To Be Defined (retry error 67).
::
:: Logging Options :
::
/L :: List only - don't copy, timestamp or delete any files.
/X :: report all eXtra files, not just those selected.
/V :: produce Verbose output, showing skipped files.
/TS :: include source file Time Stamps in the output.
/FP :: include Full Pathname of files in the output.
/BYTES :: Print sizes as bytes.
/NS :: No Size - don't log file sizes.
/NC :: No Class - don't log file classes.
/NFL :: No File List - don't log file names.
/NDL :: No Directory List - don't log directory names.
/NP :: No Progress - don't display % copied.
/ETA :: show Estimated Time of Arrival of copied files.
/LOG:file :: output status to LOG file (overwrite existing log).
/LOG+:file :: output status to LOG file (append to existing log).
/UNILOG:file :: output status to LOG file as UNICODE (overwrite existing log).
/UNILOG+:file :: output status to LOG file as UNICODE (append to existing log).
/TEE :: output to console window, as well as the log file.
/NJH :: No Job Header.
/NJS :: No Job Summary.
/UNICODE :: output status as UNICODE.
::
:: Job Options :
::
/JOB:jobname :: take parameters from the named JOB file.
/SAVE:jobname :: SAVE parameters to the named job file
/QUIT :: QUIT after processing command line (to view parameters).
/NOSD :: NO Source Directory is specified.
/NODD :: NO Destination Directory is specified.
/IF :: Include the following Files.