Jo, bin dabei.
Ich bin eigentlich Umsteiger von C++, da ich denke,
dass für meine Projekte C++ einfach unvorteilhaft wäre,
habe ich nun mit C# angefangen.
Ich habe einen Logger geschrieben,
dieser dokumentiert, wann welcher Benutzer
sich anmeldet, und nun ich will diesen so umbauen,
dass er die Uhrzeit mit einer Pseudo-Zufallszahl
multipliziert, sodass man nur mit einem bestimmten
Programm diese Uhrzeit "entschlüsseln" kann.
Der Pseudo-Zufallsfaktor wird dabei auch in eine Text-
datei hineingeschrieben.
Der Viewer[Das Entschlüsselungsprogramm] liest diesen
Faktor aus un speichert ihn. Jetzt kommt der Teil,
an dem ich hängen bleibe:
Dann liest er die verschlüsselten Zahlen aus und
devidiert diese mit dem ausgelesenen Faktor.
Wenn ich weiss, wieviele Zeichen Wert1/Wert2 (inklusive dem verbrauchen
, und diese Zahl immer gleich ist,
kann ich doch die ersten Zeichen in einen char-array und die nachfolgenden in einem anderen Array speichern. Damit dies Zeichenlänge immer dieselbe ist, muss ich Uhrzeiten [Stunden/Minuten] < 10 mit 10 multiplizieren. Richtige oder toal falsche Denkweise?
Eine Transaktion ist ein abstraktes Konzept und nicht auf Datenbanken beschränkt. Du könntest eigene transaktionale Klassen schreiben. Ich weiß leider nicht mehr, wie das in .NET funktioniert hat. Hier hab ich was gefunden, was mir vage bekannt vorkommt:
http://www.developer.com/net/net/article.php/3565196/SystemTransactions-Implement-Your-Own-Resource-Manager.htm
Auf jeden Fall könntest du das auf die Weise lösen. Das wäre aber nur die interne API, wie du Änderungen an deinem Device rückgängig machst, musst du natürlich selber wissen. Was aber schon mal gehen würde, ein TransactionScope kapselt die Datenbanktransaktion und den Zugriff auf dein Device, und wenn beim zweiten Schritt etwas schiefgeht, kann der Rollback vom TransactionScope zumindest die Datenbanktransaktion rückgängig machen.
DarkShadow44 schrieb:
sagt doch schon alles. Einfach dein C# Projekt auf x64 oder Any Cpu umstellen und es läuft ohne Probleme. Da ist doch kein hochkomplexer Umweg nötig ?
Diese Umstellung ist nicht immer klug oder erwünscht. Siehe unter anderem auch diesen Artikel:
http://blogs.msdn.com/b/rmbyers/archive/2009/06/8/anycpu-exes-are-usually-more-trouble-then-they-re-worth.aspx
Abgesehen davon können, soweit mir bekannt ist, keine 32-Bit Module aus einem 64-Bit Prozess geladen werden. Also hast du danach das Gleiche Problem in die andere Richtung
Grüssli
ok, ich werde mich wohl an services gewöhnen müssen... hab zwar schon erfahrungen, aber ich hab mich immer gewehrt dienste zu bauen...
danke für die wie immer gute hilfe hier!
hermes schrieb:
private Regex reCurrentRegex = new Regex("^[0-9]{1}\.?[0-9]{4}|^[0-9]{2}\\\?.[0-9]{4}");
Ist besser, da werde ich mich wohl noch ein wenig einarbeiten müssen.
Danke für Deine Hilfe.
Kleiner Tipp mit @ vor String-literals kannst du die Escapes sparen:
new Regex(@"^[0-9]{1}\.?[0-9]{4}$|^[0-9]{2}\?.[0-9]{4}$");
das hilft auch bei Filenames:
var superlongfilename = @"C:\Users\newuser\AppData\Roaming\"
(bei fehlenedem @ wäre zwischen Users und ewuser ein Zeilenumbruch)
Quelle:
http://msdn.microsoft.com/en-us/library/aa691090.aspx
Hallo zusammen habe vor ca. 2 Jahren ein WPF Projekt angefangen welches ich mit Visual Studio 2008 erstellt habe. jetzt habe ich das Projekt mit Visual Studio 2012 geöffnet und es wurde alles ohne Fehlermeldungen Konvertiert. Eine einzige Warnung wurde angezeigt im Migrationsbericht: "Visual Studio muss nicht funktionale Änderungen an diesem Projekt vornehmen, damit das Projekt in dieser Version und Visual Studio 2010 SP1 geöffnet werden kann, ohne dass das Verhalten von Projekten beeinflusst wird."
Wenn ich das Projekt im Debug Modus starte läuft alles einwandfrei wie vor zwei Jahren. Jetzt wollte ich an dem Projekt weiterarbeiten doch ich sehe meine Anwendungsfenster nicht in der Objektansicht. Lediglich ein graues kleines Quadrat ist zu sehen.
Der XAML Code ist jedoch vorhanden unverändert.
Wie bekomme ich meine Objektansicht wieder so hin das ich alle Buttons usw. wieder sehen?
Kennt jemand das Problem??
Hi, ich habe ne Lösung gefunden
man kann in der ZipFile Klasse den IsStreamOwner auf falsch setzten:
ZipFile.IsStreamOwner = false;
dann lässt er den Stream offen.
Allerdings funktioniert das nicht bei einen FileStream, den schließt er dann trotzdem. Ich hab mir damit geholfen,dass ich das Zip temporär in ein
MemoryStream kopiere und mit dem arbeite während ich den FileStream offen lasse und somit das File locke. Am ende Schreibe ich den Memorystream zurück.
MemoryStream tMemoryStream = new MemoryStream();
mFileStream.Position = 0;
ICSharpCode.SharpZipLib.Core.StreamUtils.Copy(mFileStream, tMemoryStream, new byte[4096]);
....
....
tZipFile = new ZipFile(tMemoryStream);
tZipFile.IsStreamOwner = false;
tZipFile.BeginUpdate();
......
....tZipFile.CommitUpdate();
tZipFile.Close();
...
...
tMemoryStream.Position = 0;
mFileStream.Position = 0;
ICSharpCode.SharpZipLib.Core.StreamUtils.Copy(tMemoryStream, mFileStream, new byte[4096]);
mFileStream.Flush();
DirectoryInfo.GetFiles() liefert dir keine Files von den Unterordnern. Wie es auch in der Dokumentation steht:
MSDN schrieb:
Returns a file list from the current directory.
Für die Lösung deines Problemes empfehle ich die Lektüre von dieser Seite:
DirectoryInfo.GetFiles(String, SearchOption)
Grüssli
Du kannst auch Image.FromFile weiterhin verwenden, musst aber halt einfach Image.Dispose aufrufen, wenn die Form geschlossen wird. Wie man dies auch in der Dokumentation nachlesen kann:
MSDN schrieb:
The file remains locked until the Image is disposed.
http://msdn.microsoft.com/en-us/library/stf701f5.aspx
Was du übrigens sowieso tun solltest, auch wenn du FileStream verwendest. Du erzeugst sonst ein mögliches Memory-Leak an GDI+ Handles.
Grüssli
Hallo qLab, ich hab mal ein kleines Testprojekt erstellt, welches Zellwerte ändert.
Der Code hier:
static void Main(string[] args)
{
DataTable dtData = new DataTable();
for (int i = 0; i < 10; i++)
dtData.Columns.Add("Spalte" + i.ToString(), typeof(int));
for (int i = 0; i < 10; i++)
{
Object[] values = new Object[dtData.Columns.Count];
for (int j = 0; j < dtData.Columns.Count; j++)
{
values[j] = i * j;
}
dtData.Rows.Add(values);
}
Console.WriteLine("Table created");
PrintTable(dtData);
Console.ReadLine();
Console.WriteLine("Updating cell values");
foreach (DataRow row in dtData.Rows)
{
foreach (DataColumn clm in dtData.Columns)
{
row[clm] = 12;
}
}
PrintTable(dtData);
Console.ReadLine();
}
private static void PrintTable(DataTable dtData)
{
foreach (DataRow row in dtData.Rows)
{
string sOutput = string.Empty;
foreach (DataColumn clm in dtData.Columns)
{
sOutput += String.Concat(clm.ColumnName, ": ", row[clm].ToString(), " - ");
}
Console.WriteLine(sOutput);
}
}
Nach der Änderung der Werte in den einzelnen Zellen, lasse ich mir diese ausgeben. Wie ich zuvor schon erwartet hatte, haben diese alle den Wert 12.
Machst du sonst noch etwas mit deiner Tabelle?
Da hast du natürlich Recht, man büßt ein gutes Stück Verallgemeinerung ein ;/ Ich hatte das damals gebraucht, um einen festen Satz an Methoden per Reflection auf verschiedene COM-Komponenten aufzurufen. Insofern war die Methodensignatur bei mir statisch
Mich interessiert aber auch, wieso Methode.Invoke sooo viel langsamer ist.. mal nach der Mittagspause forschen
Ich verwende eine COM Komponente.
Erstellt wird sie wie eine .NET Klasse:
ComComponent myCom = new ComComponent();
Beseitigt wird sie über:
System.Runtime.InteropServices.Marshal.ReleaseComObject(myCom );
Jetzt zeigt der Verweis von myCom aber immer noch irgendwo hin.
Bisher setzte ich ihn nach dem ReleaseComObject manuell auf "null".
Das mache ich aber nur, um abfragen zu können ob der Verweis noch mit dem RCW verwunden ist.
Weiß von Euch jemand, ob es eine elegantere Lösung zum Abfragen des Bestehens einer Verbindung zum RCW gibt?
Invoke führt das übergebene Delegat im GUI-Thread aus, und zwar synchron*. D.h. Dein Backgroundworker-Thread wird so lange blockiert, bis Invoke zurückkehrt. Ein Aufruf von Invoke ist auch relativ teuer.
Also wenn Du Tonnen von Berechnungen in einem Thread ausführst solltest Du nicht ständig versuchen die GUI zu aktualisieren, nur zu geschickt gewählten Zeitpunkten. Ein Mensch nimmt sowieso nicht so viele Änderungen pro Zeit wahr.
* Es gibt auch noch BeginInvoke zu asynchronen Ausführung
