SeppJ schrieb:
Du kannst es auch gerne anders lösen, meines ist nur ein möglicher Vorschlag, wie du ohne viel Denken zum Ziel kommen kannst. Hauptsache, du verstehst das Problem am jetzigen Ansatz.
Ich bin für jede Art der Hilfe dankbar und deshalb danke das du dir mein Anliegen durchgelesen hast und etwas dazu geschrieben hast ist ja alles freiwillig hier
Ja ich verstehe was mein momentanes Problem ist und zwar komme ich mit meinem momentanen Lösungsweg nicht weit da mein Programm erst die 8er ausprobiert sie dann jedoch komplett weglässt und alles mit der 5 versucht und so weiter... Deshalb bin ich momentan noch damit beschäftigt mir einen anderen weg auszudenken und habe da erstmal genug zu tun deshalb danke für jegliche Art von Tipps
Liebe Kollegen,
ich versuche derzeit ein kleines Excel-Addin zu entwickeln das auch eine große Anzahl an Daten in Zellen zu schreiben hat.
Dafür gibt es im Excel Objektmodell ja die Möglichkeit über ScreenUpdating = False die Bildschirmaktualisierungen abzuschalten und so mehr Geschwindigkeit zu bekommen.
Dies funktioniert aber leider nicht wenn ich ScreenUpdating = False aus meinem Backgroundworker aufrufe. Auch ein Aufruf vor Start des BGW ändert daran nichts. Verzichtet man auf den BGW klappt es aber.
Kann mir jemand sagen was ich falsch mache oder hat jemand eine Alternative?
Globals.ThisAddIn.Application.ScreenUpdating = False
Vielen Dank
CJens schrieb:
Kann ich die Referenz vielleicht als private Variable (wie man priv. Variablen in einer Parallel.For Schleife erzeugt weiß ich) übergeben oder wo liegt hier das Problem?
Ich vermute dass du das richtige meinst. Wenn du es in Code zeigst könnten wir es dir sicher sagen.
Zum Thema warum das so wie du es versucht hast nicht erlaubt ist...
Also es geht nicht, weil es nur mit viel Overhead umsetzbar wäre. Und vor allem Overhead der überall zu bezahlen wäre wo man Zeugs per ref bzw. out übergibt, egal ob das dann an Lambdas weitergereicht wird oder nicht.
Grund ist dass bei nem ref bzw. out Parameter quasi die Adresse einer Variable der aufrufenden Funktion übergeben wird. (Bzw. auch evtl. die Adresse einer Membervariable eines Objekts, aber das wäre die weniger problematische Variante.)
Lokale Variablen leben typischerweise auf dem Stack, und werden damit ungültig sobald die Funktion der sie gehören verlassen wird. Das Lambda kann aber ne beliebig lange Lebenszeit haben. Daher darf man dem Lambda die Adresse einer lokalen Variable nicht geben. Daher kein ref/out bei Lambdas.
Du kannst aber natürlich den aktuellen Wert eines ref/out Parameters in eine andere, eigene lokale Variable kopieren und diese dann im Lambda einfangen.
Ein Frager schrieb:
Ist eine Struct oder Klasse in einer Klasse guter Programmierstil? Eine Konstruktion wie in diesem Thread hab ich bisher in keinem Lehrbuch oder Tut gesehen.
Ist schon okay, wenn man eine Hilfsklasse braucht und diese z.B. nur innerhalb einer Klasse verfügbar/sichtbar sein soll.
Ja, du kannst den Operator mit zwei unterschiedlichen Datentypen bei den Parametern erstellen - einer davon muß aber gleich der Klasse sein, in der dieser Operator definiert wurde, s.a. Überladbare Operatoren (ich würde daher immer den ersten Parameter gleich der Klasse wählen).
Mußt aber aufpassen, daß du bei der Implementierung keine Rekursion einbaust, wenn du bei der Addition eine andere Addition aufrufst (d.h. am besten jeweils den Grunddatentyp (decimal) verwenden).
DANKE!
Habe es jetzt auch auf der Kommandozeile hinbekommen. Das extern "C" war doch nötig
Falls es jemanden interessiert:
Die CLR nimmt immer die zum System passende Version, das heißt, auf einem 64-Bit-System die 64-Bit-Version. Die Kommandozeile (und Visual Studio auch?) kompilieren Maschinencode aber zumindest auf Windows 7 standardmäßig nach 32 Bit. Anstatt der Standradeingabeaufforderung muss man dann im Startmenu nach der 64-Bit Native Tools Eingabeaufforderung suchen, um eine 64-Bit-DLL zu bekommen.
Alternativ kann man mit der /platform die CLR-Exe auf 32- oder 64-Bit beschränken
Adrox schrieb:
Hättest du da zufälligerweise ein paar Links? Würde mich mal interessieren
Eine Sammlung freier Ebooks (u.a. auch C#/.Net-Themen):
122 kostenlose Bücher für Entwickler
Eine weitere Sammlung
Ohne das Buch zu kennen, nehme ich in der Regel von Galileo-Büchern sowie deutschen Büchern abstand, es gibt aber in beiden Fällen gute (wenn auch seltene) Ausnahmen.
Technisch gesehen gibt es bei .NET-Assemblies keinen Unterschied zwischen EXE und DLL.
Wenn du aber aus deinen EXE-Projekten DLLs machen willst, dann stell einfach das Projekt auf "Library" (Bibliothek) um - und dann referenziere diese ("Verweise") in deinem Hauptprojekt.
Hallo,
ich habe eine ungebundene DataGridView. U.a. sind dort Spalten für Geldbeträge.
Ändert der Nutzer nun einen Preis, soll diese Spalte und die Gesamtpreis-Spalte (nach dem Verlassen der Zelle) wieder als Währung angezeigt werden.
Für die Spalte Gesamtpreis (preis*anzahl, d.h. hier kann der Nutzer auch nichts direkt eintragen) addiere ich alle Preise auf und formatiere am Ende:
string str = dgPreisberechnung["gesamt", x].Value.ToString();
decimal deci;
bool convert = decimal.TryParse(str, NumberStyles.Currency, CultureInfo.CurrentCulture.NumberFormat, out deci);
if (convert)
summe += deci;
dgPreisberechnung.Columns["gesamt"].DefaultCellStyle.Format = "c2";
Dies funktioniert alles prima!!
Nur wie kann ich die Zelle, in der Nutzer "5" einträgt beim Verlassen zu "5,00 €" formatieren???
Mit dgPreisberechnung.Columns["preis"].DefaultCellStyle.Format = "c2"; passiert leider nichts -> es bleibt einfach "5" stehen.
Wie kann ich also die Spalte bzw. eigentlich nur die eine Zelle, in die gerade editiert wurde, richtig formatieren?
Was dir helfen kann ist das ICustomMarshaler Interface.
Für dein Struct reicht ein
struct MyNativStruct
{
byte[] data;
}
Bei der Invoke Definition machst du dann
[DllImport("meine.dll")]
public static extern void myNativMethod([MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(MyCustomMarshaler))] MyNativStruct param);
Und eben noch als eigener Marshaller etwas in folgender Richtung
public class MyCustomMarshaler : ICustomMarshaler
{
public void CleanUpManagedData(object ManagedObj)
{
}
public void CleanUpNativeData(IntPtr pNativeData)
{
Marshal.FreeHGlobal(pNativeData);
}
public int GetNativeDataSize()
{
throw new NotImplementedException();
}
public virtual IntPtr MarshalManagedToNative(object ManagedObj)
{
if (ManagedObj == null)
return IntPtr.Zero;
if (!(ManagedObj is MyNativStruct))
throw new MarshalDirectiveException("check your P/Invoke");
MyNativStruct s = (MyNativStruct)ManagedObj;
IntPtr pNativeData = Marshal.AllocHGlobal(4 + s.data.Length);
Marshal.Write(pNativData, s.data.Length);
Marshal.Copy(s.data, 0, IntPtr.Add(pNativeData, 4), s.data.Length);
return pNativeData;
}
public virtual object MarshalNativeToManaged(IntPtr pNativeData)
{
if (pNativeData == IntPtr.Zero)
return null;
MyNativStruct s = new MyNativStruct();
int size = Marshal.ReadInt32(pNativData);
s.data = new byte[size];
Marshal.Copy(pNativData, s.data, 0, s.data.Length);
return s;
}
}
