Noch ein Versuch:

Ich möchte MVVM im resultierenden Projekt verwenden! Unbedingt! 😉

Ich wollte es nur für das Gedankenspiel jetzt schnell weglassen, um primär den Fokus auf die wohl notwendige Bearbeitung der Projekt-Datei, sowie sekundär den Austausch der Form-Dateien zu lenken.

Ich möchte nicht pfuschen.

Ich möchte lediglich das Projekt von WF auf WPF umstellen und dann ganz gesittet, verantwortungsvoll und zielgerichtet ein WPF UI aufzubauen, mit allen Paradigmen, die das so mit sich bringt und auch voraussetzt. 😃

Das einzige was ich nicht möchte ist, ein neues Projekt zu erstellen.

Nun klar?

Edit:
Noch ein Zusatz, was das Ziel ist:
Im aktuellen WF Projekt kann ich nur WF Forms hinzufügen, jedoch keine WPF-Forms.
Nach der erhofften Bearbeitung der Projektdatei möchte ich nur noch WPF-Forms und keine WF Forms mehr hinzufügen können.

Edit2:
Ich habe nun hier auf die Frage "Convert csproj file from winform to wpf" eines Anderen diese Aussage gefunden:

The short answer for those that don't want to do the comparison themselves is that a WPF .csproj file contains an addition property:

<ProjectTypeGuids>{60dc8134-eba5-43b8-bcc9-bb4bc16c2548};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</ProjectTypeGuids>  

Just put that in the first <PropertyGroup>...</PropertyGroup> section, it shouldn't matter where.

The meaning of {60dc8134-eba5-43b8-bcc9-bb4bc16c2548} is that this is a WPF project, and {FAE04EC0-301F-11D3-BF4B-00C04F79EFBC} indicates a C# project.

Außerdem verweist der Antwortende noch auf diesen Beitrag:
http://stackoverflow.com/questions/10802198/visual-studio-project-type-guids

Ich werde mir das morgen einmal näher anschauen.

Hat denn zufällig jemand von euch das so schon einmal gemacht?

Da hast du mich leider falsch verstanden.

Ich hatte gehofft klar gemacht zu haben, dass ich das Projekt durchaus als 'korrektes' WPF-Projekt aufziehen möchte, auch mit MVVM.
Nur gedanklich, um das Projekt selber von Windows Forms auf WPF umzustellen, wollte ich der Einfachheit halber MVVM gedanklich weglassen.

Frickeln möchte ich nichts, nur händisch das Projekt von Windows Forms auf WPF umstellen.

Danach möchte ich das Windows Form löschen und ein WPF-UI mit MVVM implementieren.

Hallo,

ich habe schon im Internet gesucht, aber entweder mit den falschen Begriffen, oder nicht gründlich genug.
Jedenfalls finde ich nicht konkret für meinen Bedarf Antworten.

Ein bestehendes Windows Forms-Projekt soll in ein WPF-Projekt 'konvertiert' werden.

Das Projekt hat nur ein einziges Windows Form und das möchte ich gerne komplett neu aufbauen.
Es geht also nicht um das Konvertieren der Windows Forms.

Zielsetzung meiner Frage ist, dass ich wissen möchte, ob und wie ich das Projekt selber von Windows Form zu WPF konvertieren kann.

Ich möchte bewusst kein neues Projekt erstellen und die anderen Dateien importieren!

Hintergrund, auch wenn ich das eigentlich mal als gegeben nennen und nicht diskutieren möchte, ist, dass ich im Sourcecode Management System möglichst wenig ändern, also einen möglichst kleinen Footprint hinterlassen möchte.

Allein mit dem Löschen und Hinzufügen der entsprechenden Verweise ist es leider nicht getan.

Aber eigentlich müsste es sich doch mit dem Überarbeiten der Projektdatei und dem Austausch des UI-Forms, wenn wir MVVM hier vom Ansatz mal gedanklich weglassen, umsetzen lassen, oder?

Vielleicht hat das ja schon einmal jemand gemacht?

Vielen Dank!

Und ja, ich meinte natürlich "K" und nicht "L". Hab's schnell korrigiert. 😉

Bzgl. der Signatur hätte ich in der Tat selber nachschauen können, aber das war ja eher eine 'spontane Zwischenfrage'. 😉

Danke für die schnelle Antwort!

Ich könnte also "L" beliebig 'aufbohren', auch um Klassen mit non-static Members erweitern usw., und "K" würde "L" weiterhin ohne Murren akzeptieren solange der Name und die Signatur von "M" gleich bleibt (gehört der Name eigentlich auch zur Signatur? 😃 )?

Edit:
Habe gerade gesehen, dass du editiert hast. Lese noch mal schnell durch. 😉

Edit2:
Ok, danke für die Ergänzung.
Aber im zuerst skizzierten Fall von dir, also ohne speziell referenzierte Version, würde meine Frage oben positiv beantwortet werden können?

Hallo.

Ich hätte eine Frage zur Verwendung von Assemblies (DLL) in anderen Projekten:

Ich habe ein Library-Projekt "L", welches ausschließlich eine DLL mit einer statischen Methoden "M" erstellt.

Diese Assembly (DLL-Datei) habe ich nun in einem Konsolen-Projekt "K" referenziert und nutze die Methode "M" darin.
Das Projekt "K" habe ich nun ebenfalls kompiliert und die EXE mit der DLL in einen anderen Ordner "O" kopiert.

Nun habe ich das Projekt "L" modifiziert, indem ich weitere Methoden mit unterschiedlichsten Namen und Signaturen hinzugefügt, sowie die Assembly- und Dateiversion inkrementiert habe.
Das neue Kompilat (die DLL) habe ich nun in den Ordner "O" kopiert und die alte DLL damit überschrieben.

Womit ich nicht gerechnet hätte:
Die EXE lässt sich nach wie vor starten und läuft sauber.

Warum ist das so?

Hallo und danke dir für die Antwort!

Leider ist 4.0 fix, das hatte ich schon angefragt. 😕

Gru0,
AtzeX

Hallo zusammen,

leider kann ich nicht allzuviel meiner Zeit in C#/.Net Programmierung investieren, da ich viel mit anderen Projekten zu tun habe.
Mein letztes 'richtiges' C#-Projekt habe ich noch unter dem Framework 2.0 entwickelt.

Nun steht ein größerer Umbau dieses Projektes an und ich habe die Möglichkeit das Framework 4.0 (Kundenvorgabe) zu verwenden.

Das Projekt ist ein Windows Forms-Projekt, jedoch kann sich das im Zuge des Umbaus auch zu WPF entwickeln.

Da ich so eine Gelegenheit natürlich nutzen möchte, mich und meine C# Kenntnisse weiter zu entwickeln, möchte ich schauen, was ich nun besser/anders/eleganter umsetzen kann.

Deshalb meine Frage, ob es irgendwo eine gute Übersicht gibt, was sich zwischen 2.0 und 4.0 getan hat.
Gibt es evtl. auch eine Art 'Best Practices' oder so?

Danke im Voraus!

AtzeX

Hat evtl. jemand eine Idee, wo man da sonst mehr Infos zu bekommen könnte?

Hallo.

In der Beschreibung zum ServiceInstaller finden sich Aussagen wie diese:

ServiceName must equal those on ServiceBase derived classes.

It is crucial that the ServiceName be identical to the ServiceBase.ServiceName of the class you derived from ServiceBase.

Nur finde ich keine Begründung dafür, warum das so sehr wichtig ist, denn mein Dienst kann sowohl installiert als auch genutzt werden, wenn diese Bedingung NICHT erfüllt ist.

Übersehe ich etwas?

Du meinst, ich sollte mir selber eine Suchfunktion erstellen?

Theoretisch stimme ich zu, wobei das gerade beim Mehrzeiligen Kommentar doch eher kompliziert werden würde.
Denn die ersten beiden sind Einzeilig zu betrachten und der dritte ja nicht...

Hallo,

ich möchte gerne im meiner Solution nach einem Text suchen, dabei jedoch verhindern, dass auch in Kommentaren gesucht wird.
Eine solche Option im Suchdialog wäre klasse, gibt es jedoch in Visual Studio 2010 nicht.

Gibt es eine Möglichkeit oder z.B. ein AddIn um dies zu bewerkstelligen?

Danke euch!

Sonst noch Meinungen oder Bekundungen angewandter Praxen?
Bin nach wie vor neugierig! 😉

Gruß,
AtzeX

Hallo und danke für die Antworten!

@myUnderTakeR:
Mir geht es nicht um den konstruierten Fall, also den Sinn des Beispiels, sondern um den Vergleich dieser beiden angesprochenen Praktiken. 😉

@chilic:
Ja, da hast du Recht, es kommt sicherlich auf den Fall an.
Aber kann man sagen, welche Vorteile/Nachteile sich ergeben?

Wenn ich den Member z.B. als Parameter übergebe, sehe ich im aufrufenden Code direkt, dass die aufgerufene Methode damit etwas anstellt.
Wenn sie jedoch direkt das Feld verwendet, sehe ich das nicht so leicht.
Es könnten ja u.U. auch mehrere Felder sein, die die Methode intern verarbeitet.
Da sieht man nicht direkt dass dem so ist. Als Parameter hingegen schon.
Andererseits wären, sagen wir mal 10 Parameter, auch nicht gerade elegant, oder?

Vielleicht gibt es ja noch mehr Vor- oder Nachteile, an die man so direkt nicht denkt?

@JuyJuka:
So egal ist mir das bei privaten Methoden auch nicht, da ich mir Gedanken über einen Programmierstil mache. Deshalb ja die Frage. Funktionieren tut ja beides. 😃

Warum würdest du das Feld über eine Property verwenden?
Und warum sollte diese virtuell sein?

Ich merke jetzt, dass meine Frage eher philisophisch ist, aber guter Stil ist mir halt wichtig. Da arbeite ich gerne dran.
Und schlimmer ist's noch, wenn ich Nachteile einer verwendeten Implementierung übersehe.
Geht das nur mir so? 😃

Hallo zusammen.

Ich habe eine recht allgemeine Frage in Bezug auf zwei alternative Möglichkeiten zur Verwendung von / zum Zugriff auf Felder innerhalb von privaten Methoden der selben Klasse.

Lektüre, die das behandelt finde ich leider keine.

Von daher frage ich hier mal in die Runde und habe dazu ein 'doofes' Beispiel gemacht.

Entweder ich nutze in der privaten Methode direkt das Feld:

class FooBar
{
    private string _filename;

    .
    .
    .

    public string Foo()
    {
        Bar(5);
    }

    private string Bar(int amount)
    {
        DoSomethingWithFile(_filename, amount);
    }

    .
    .
    .

}

Oder ich übergebe das Feld als Parameter an die Methode:

class FooBar
{
    private string _filename;

    .
    .
    .

    public string Foo()
    {
        Bar(_filename, 5);
    }

    private string Bar(string filename, int amount)
    {
        DoSomethingWithFile(filename, amount);
    }

    .
    .
    .

}

Wie verfahrt ihr? Was seht ihr für Vor- und Nachteile in den beiden Ansätzen?

Und wie ist das in Anbetracht von Feldern abgeleiteter Klassen zu bewerten?

Danke im Voraus,
AtzeX

Hallo zusammen,

da ja wieder über ein Jahr ins Land gegangen ist und mich das Thema hin und wieder doch noch nervt, erlaube ich mir, einmal nachzufragen, ob es da mittlerweile neue Möglichkeiten gibt?

Vielleicht eine kleine aber feine API, die mir noch unbekannt ist? 😃

Gruß,
AtzeX

Hallo.

Ich muss HTML in PNG konvertieren und habe dazu ein WinForm mit einem WebBrowser-Control erstellt, welches ich mit dem HTML-String füttere.

Das wird auch prima gerendert.
Nun speichere ich dies mittels einer hier im Forum gefundenen Routine:

            // Get the image width and height 
            int screenWidth = webBrowser1.Width;
            int screenHeight = webBrowser1.Height;

            // Set hwnd to the WebBrowser 
            IntPtr myIntptr = this.webBrowser1.Handle;
            int hwndInt = myIntptr.ToInt32();
            IntPtr hwnd = myIntptr;

            // Set hdc to the bitmap 
            Bitmap bm = new Bitmap(screenWidth, screenHeight, System.Drawing.Imaging.PixelFormat.Format16bppRgb555);
            Graphics g = Graphics.FromImage(bm);
            IntPtr hdc = g.GetHdc();

            // Snapshot the WebBrowser 
            bool result = PrintWindow(hwnd, hdc, 0);
            g.ReleaseHdc(hdc);
            g.Flush();

            // Save the bitmap, if successful
            if (result)
                bm.Save(@"Z:\out.png", System.Drawing.Imaging.ImageFormat.Png);

Das resultierende Image hat dann leider nur 96DPI.
Das scheint die des Bildschrims zu sein, da ja quasi ein Screenshot gemacht wurde.

Wenn ich das nun ausdrucke, ist die Qualität entsprechend schlecht.

Meine Frage ist nun:
Habe ich irgendeine Chance, das Image z.B. mit 300DPI zu erstellen?

Gruß,
AtzeX

Ist zumindest ne Idee.
Ich denke mal drüber nach.

Danke dir!

Ich kann mir das eigentlich nicht vorstellen.
Vielleicht sieht das nur so aus, als wäre das ein einzelnes Objekt/Control.

Ich vermute eher, dass es einzelne Textfelder sind, die optisch mit einem darunterliegenden Grid-Control 'harmonisieren'.

Oder es sind zwei Grid-Controls.
Das obere immer mit einer Zeile und das untere mit den Daten.
Je mehr ich darüber nachdenke, deso eher denke ich, dass es so gelöst wurde.
Das hätte den Vorteil die Spaltenbreiten auch in gleicher Weise synchron zu halten...

Zeig doch mal einen Screenshot.

Gruß,
AtzeX

Hi, danke auch dir.

Die Variable alleine wäre dann aber nicht über Assembly-Grenzen hinweg verfügbar. 😉

Gruß,
AtzeX

Hi, danke für deine Antwort.

Wenn du oben geschrieben hast dass über eine Datenbank parametrisiert wird wäre die Datenbank eine Alternative 😉

Nicht unbedingt, denn dann müsste ich diese Information, welche ich aus der Datenbank gewonnen habe, an jede noch so kleine Assembly immer 'durchreichen'.

Oder jede Assembly würde selber an die DB connecten, was aber schon vom Anwendungsdesign her wegfällt.

Der Vorteil meines Ansatzes ist ja die 'quasi Automatik', welche zudem Assembly-übergreifend ist.

Bin aber natürlich für Ideen/Vorschläge offen.

Gruß,
AtzeX

Das ungewollte Überschreiben eines bestehenden Wertes bzw. ungewollte Seiteneffekte kann man ja durch einen etwas außergewöhnlichen Namen umgehen.
Ansonsten spricht jetzt aber wohl nicht wirklich etwas gegen diese Lösung...

Gibt es denn Alternativen (außer der App.Config)?

Hi, danke für den Reply.

Könntest du mir auch sagen, warum das ungeeignet ist?

Edit:
Was meinerseits gegen eine "App.config" spricht, ist, dass ich meine Anwendung (natürlich je nach Anwendungsfall, aber in diesem ist es so) bis auf Ausnahmen über eine zentrale SQL-Datenbank parametrisiere.

Hallo zusammen,

ich überlege, wie ich Assembly-überreifend eine 'globale Variable' erstellen kann.

Der Hintergrund ist der, dass ich in meinem Projekt, welches aus mehreren Assemblies besteht, Code nur ausführen lassen möchte, wenn ich im "Debug"-Modus bin.

Natürlich könnte ich mit der "/DEBUG"-Konstante, bedingter Kompilierung und zwei Sätzen von Assemblies arbeiten, jedoch möchte ich das nicht.
Ich möchte auch im Release meinen 'Debug-Modus' ein- und ausschalten und diesen damit nutzen können.
Hinzu kommt, dass die ein oder andere Assembly gar nicht zum Projekt gehört, sondern als Binary referenziert wird.

Ich habe mir nun folgendes ausgedacht:
In der eigentlichen ausführenden Assembly, also im gegebenen Fall meiner EXE-Datei, habe ich ein Feld

static private bool _debug = false;

hinzugefügt, welches ich z.B. (in diesem Falle exemplarisch fest codiert) mittels einer ebenfalls hier erzeugten AppicationDomain-Property setze:

AppDomain.CurrentDomain.SetData("DEBUG", "True");
_debug = (AppDomain.CurrentDomain.GetData("DEBUG").ToUpper() == "TRUE");

Der Vorteil ist, dass ich in allen meinen Assemblies, welche ich referenziere, nun mit einem Feld wie

static private bool _debug = (String.Format("{0}", AppDomain.CurrentDomain.GetData("DEBUG")).ToUpper() == "TRUE");

diese Property nutzen kann.

Performancetechnisch sollte das kein Engpass sein.

Auch habe ich nicht vor, mehr als eine AppDomain zu verwenden.

Was spricht gegen diesen Ansatz, bzw. was für Alternativen gäbe es?

Gruß,
AtzeX

So, ich habe mir mal Testroutinen gemacht.
Alles in allem ist die Technik mit dem StackFrame langsamer, aber das ist im Kontext der Verwendung eher marginal.

Bei 1000000 Wiederholungen habe ich einen Faktor 2-4, je nach CPU-Type (bei x86 ist der Faktor ca. 2, bei x64 ist er ca. 4).

Bei 1000 Wiederholungen sind die Faktoren in etwa gleich (also nach wie vor 2 bzw. 4), aber auf meinem Rechner lediglich im Bereich von 10-20 Millisekunden Unterschied.

Von daher werde ich die Stackframes verwenden.

Gruß,
Axel

Danke dir, werde ich mir morgen durchlesen. 😃

Ich hatte ja schon darauf gehofft, dass diese Erfahrungen hier schon mal gesammelt wurden.

Wenn ich das selber teste, muss ich ja, wie du schon schreibst, darauf achten, keine verfälschten Testergebnisse zu produzieren.
Nur wie soll ich das beeinflussen.
Woher soll ich wissen, was der Compiler bei Schleifen z.B. 'weg-optimiert'?

Gruß,
AtzeX

Hallo zusammen.

Momentan nutze ich folgende Membervariable um mir die Klasse für das Logging zu merken:

private static string _className = System.Reflection.MethodBase.GetCurrentMethod().DeclaringType.Name;

Zudem habe ich in jeder Methode, in welcher ich etwas loggen möchte, ganz oben diese Zeile um die aktuelle Methode zu ermitteln:

string methodName = System.Reflection.MethodBase.GetCurrentMethod().Name;

Verwenden tue ich das dann z.B: mit einer statischen Log-Methode (exemplarisch):

Logging.Log(_className, methodName, "Meine Meldung.")

Nun überlege ich, ob ich die Ermittlung des Klassennamens und der Methodennamens nicht doch in die statische Methode "Log" verlege und dort z.B. mit

...System.Diagnostics.StackFrame(1).GetMethod().Name

usw. ermittle.

Ich würde nun gerne wissen, ob das Laufzeitverhalten dadurch verschlechtert wird.
Oder ist das eher marginal?

Gruß,
AtzeX

@dr4g0n76:
Wenn ich dich richtig verstehe, meinst du diesen Code, richtig?

#define FW(x,y) FindWindowEx(x, NULL, y, L"")
void RefreshTaskbarNotificationArea(){
    HWND hNotificationArea;
    RECT r;
    GetClientRect(
        hNotificationArea = FindWindowEx(
            FW(FW(FW(NULL, L"Shell_TrayWnd"), L"TrayNotifyWnd"), L"SysPager"),
            NULL,
            L"ToolbarWindow32",
            L"Notification Area"),
        &r);
    for (LONG x = 0; x < r.right; x += 5)
        for (LONG y = 0; y < r.bottom; y += 5)
            SendMessage(
                hNotificationArea,
                WM_MOUSEMOVE,
                0,
                (y << 16) + x);
}

Bevor ich versuche den auf C# umzubauen:
Wenn ich richtig sehe, simuliert der aber auch die Maus, oder etwa nicht?

Gruß,
AtzeX

@zero_x, Lennart:
Danke nochmal, aber ich habe gerade zufällig festgestellt, dass das (natürlich) nicht funktioniert, wenn die Taskleiste automatisch ausgeblendet wird.
Dann ist sie nicht sichtbar und der Maustrick funktioniert nicht.

Ist aber nicht so schlimm.
Das Problem ist kein großes, es wäre nur schön gewesen, wenn mittlerweile eine einfache verlässliche Lösung existiert hätte.

@Lennart:
Funktioniert bei mir leider gar nicht.

Edit:
Funktioniert doch, aber nicht immer.

Edit2:
Funktioniert nur, wenn ich über Cursor.Position = new Point(i, maxY + 15); ein System.Threading.Thread.Sleep(1); einbaue.

Allerdings ist das Ganze recht 'weak'.

Gruß,
Axel

@herbivore:
Danke dir.

@zero_x:
Danke dir besonders, aber bis ich das auf C# umgebaut habe, ist Weihnachten. 😉

Ist jemandem bekannt, ob es da evtl. mittlerweile eine vom Betriebssystem bereitgestellte Lösung für gibt?

Hi ErfinderDesRades,
danke für deine rasche Antwort.

Da finde ich jetzt dein Ansinnen "verhindern, dass der Benutzer ohne zu speichern Änderungen an Datensätzen vornimmt" konträr zum Konzept.

Aber mit DGV_RowValidating sollteste da weiter kommen (e.Cancel=true). Damit zwingste zwar nicht zum Speichern, aber zur Korrektur direkt nach Fehleingabe ("Harte Validierung") Naja, sagen wir mal es ist das Harte-Konzept, aber mit ErrorProvider zum Anzeigen, wo es hakt.
Spricht doch eigentlich nichts dagegen. Es sei denn, dass der 'DataTable.RowChanged' Event noch gar nicht gefeuert wurde, bevor ich DGV_RowValidating abfange. Muss ich erst einmal probieren.

Ühaupt ist jede Änderung gleich in die DB zu schreiben nicht die Idee von ADO und Dataset. Sondern man holt sich ein Dataset, wurstelt drin rum, und speichert die Gesamt-Änderungen zurück.

Naja, mag sein, aber es ist die Idee der Anwendung, das so zu machen.
Womit ließe sich das besser lösen?

Jo, da musste entweder iwas inne DB ändern, dass die selber merkt, wenn die änderung nix ändert, oder beim Speichern die Werte von DataRow(,,,System.Data.DataRowVersion.Original) vergleichen. Bei Identität aller Spalten, kann der System.Data.DataRow.AcceptChanges() dafür sorgen, daß diese Row vom Update ausgenommen wird.

Ok, werde ich mir mal ansehen bzw. testweise umsetzen.
Aber du meinst doch sicherlich "System.Data.DataRow.RejectChanges()" und nicht "System.Data.DataRow.AcceptChanges()", oder?

Gruß,
AtzeX

Hallo.

Mit folgendem Aufbau habe ich recht einfach eine kleine Datanbankgestützte WinForms-Anwendung erstellt, welche die Daten(-sätze) einer Tabelle editierbar in einem DataGridView und in einem 'Detail-View' (also einzelnen Controls) darstellt:

Database
|
TableAdapter
|
Typed DataSet
|
BindingSource
|
(Form-)Control

DataValidation habe ich zentral im Typed Dataset mittels "SetColumnError" implementiert, so dass sowohl im Grid, als auch im Detail-Bereich etwaige Fehler angezeigt werden.

Jetzt habe ich aber das Problem, dass ich gerne jeden Datensatzwechselversuch abfangen möchte, um zu verhindern, dass der Benutzer ohne zu speichern Änderungen an Datensätzen vornehmen kann.
Ich finde nur keinen Event, den ich z.B. in Verbindung mit einem Cancel-EventArg nutzen könnte.

Sollte es definitiv nicht möglich sein, so würde ich gerne z.B. im DataGridView den Status jedes Dateisatzes, also DataRow.RowState, anzeigen lassen.
Dazu hab eich schon versucht ein 'berechnetes Feld' im Typed Dataset hinzuzufügen, aber den Zustand kann ich mir dort nicht anzeigen lassen.
Das Problem ist nämlich, dass der Anwender momentan durch die Datensätze 'springen' und überall etwas ändern kann.
Fehlerhafte Eingaben werden zwar dargestellt, aber nicht, welche Datensätze z.B. neu von ihm hinzugefügt wurden und welche ohne Fehler editiert wurden.

Ich möchte nämlich z.B. auch verhindern, dass Datensätze, welche zwar editiert, aber wieder auf ihre eigentlichen Feldwerte 'zurück-editiert' wurden, gespeichert werden müssen, da das z.B. einen Trigger im Datensatz auslösen würde, welcher das 'Letzte Bearbeitungsdatum' einsetzen würde.
Nur wurde ja eigentlich nichts geändert. Der Benutzer soll in diesem Fall den Datensatz zurücksetzen können.

Vielleicht liest der ein oder andere heraus, dass ich eine Zeit lang Anwendungen mit Microsoft Access erstellt habe, wo so etwas ein Klacks war.

Ich würde das aber gerne mit .Net umsetzen.
Nur komme ich momentan nicht weiter.

Gruß,
AtzeX

Weiß jemand, ob Updates (insbesondere zeitnahe Security-Patches) zu Windows 7 RC über Windows-Update, oder etl. auch WSUS zur Verfügung gestellt werden?

Setzt du die 32bit oder 64bit Version ein?
Das würde mich interessieren.

Danke dir für die Aussage.
Das ist eine gute Information.

Gruß,
AtzeX

Das war/ist darin bedingt, dass ich es nicht ans Laufen bekommen habe, und mir dann nicht sicher war, ob "Exception" ausreicht um alle Exceptions abzufangen.
Ich vermutete in meiner Verzweiflung ein Typ-Problem und habe dann mal mittels Reflektor etwas tiefer reingeschaut.
Ich habe es aber nun wieder auf "Exception" umgestellt und es funktioniert prima.

Gruß,
AtzeX

Edit:
Hier die 'fertige' Version:

public static class ExceptionExtensions
{
    /// <summary>
    /// Determines and concatenates all nested message-properties of an exception.
    /// </summary>
    /// <returns>All nested messages separated by new-lines.</returns>
    public static string NestedMessages(this Exception e)
    {
        string messages = String.Empty;
        while (e != null)
        {
            messages += e.Message;
            if (e.InnerException != null) messages += "\r\n";
            e = e.InnerException;
        }
        return messages;
    }
}

Hallo zusammen.

Ich habe vor, mir eine Erweiterungsmethode für Exceptions zu definieren.
Leider klappt das nicht. Die MEthode taucht nicht im Intelli-Sense auf.

Anbei meine Klasse. Hat jemand eine Idee, warum das nicht funktioniert?

public static class ExceptionExtensions
{
    /// <summary>
    /// Determines and concatenates all nested message-properties of an exception.
    /// </summary>
    /// <param name="value">The string value to check.</param>
    public static string NestedMessages(this System.Runtime.InteropServices._Exception e)
    {
        string messages = String.Empty;
        System.Runtime.InteropServices._Exception exception = e;
        while (1 == 1)
        {
            if (exception == null)
                break;
            messages += String.Format("{0}\r\n", exception.Message);
            exception = exception.InnerException;
        }
        return messages;
    }
}

Gruß,
AtzeX

Edit:
Scheint doch zu gehen, ich kontrolliere noch einmal alles.

Edit2:
Ok, mein (leider übersehener) Fehler war eine fehlende Referenz auf mein "Extensions"-Projekt. 😃
Von daher hat es sich erledigt.

Hi herbivore.

Das hatte ich gestern auch schon probiert.
Allerdings kam ich damit nicht zum Erfolg.
Nun habe ich mich heute morgen noch mal frischen Mutes drangesetzt und nun hat es geklappt:

\[€?[a-zA-Z]{4}:[ ]
(?!.*\[€?[a-zA-Z]{4}:[ ].*)
.*?
\]

Ich hatte es gestern versäumt die ".*" im negativen Lookahead zu integrieren.
Dazu noch einen Lazy-Quantifier an der richtigen Stelle und alles funktioniert.

P.S.:
Für die besonders aufmerksamen Leser: Gestern Abend hatte ich vergessen zu erwähnen, dass ein "€" alternativ enthalten sein kann, aber es in meinem RegEx aufgeführt. Sorry, falls es zu Konfusion geführt hat.

Nochmal danke an herbivore, oder darf ich herbie sagen? 😉

Hallo.

Ich verzweifle langsam an meiner selbst gestellten Herausforderung. 😃

Um es auf den Punkt zu bringen, möchte ich, dass alle Zeichen erlaubt sind, außer einem bestimmten Muster.

Beispiel:
Mit

[^a]*

kann ich ja definieren, dass beliebige Zeichen, außer einem 'a' erlaubt sind.

Nun möchte ich aber alle Zeichen zulassen, außer einem bestimmten Muster wie z.B.

\[€?[a-zA-Z]{2}:[ ]

Geht das irgendwie?

Hintergrund:
Ich habe eine Art Syntax, bei welcher 'Kommandos' durch ein bestimmtes Kopfmuster eingeleitet und mit einer eckigen Klammer abgeschlossen werden.
Ein solches Kommando könnte so aussehen:

[AA: foo]

Der sogenannte Kopf wäre dann "[AA: " (inkl. dem Blank).
Der Inhalt wäre "foo" und das Kommando wird beendet mit "]".

Mit folgender RegExp klappt das auch prima:

\[€?[a-zA-Z]{4}:[ ].*\]

.
Allerdings können die Kommandos auch verschachtelt sein:

[AA: foo[BB: xxx]]

Was ich nun brauche ist nur das 'Innerste' Kommando, also "[BB: xxx]".
Mit meiner RegExp bekomme ich aber "[AA: foo[BB: xxx]]".

Ich muss der RegExp also irgendwie sagen, dass ich nach dem ersten 'Kopf' ("[AA: ") bis zum "]" keinen weiteren Kopf mehr haben darf.

Kann mir jemand helfen?

Ich liebe solche Antworten. 😃

Kurz, Präzise, gut erklärt und wirklich einleuchtend.

Danke dir!

Hallo zusammen.

Ich habe eine recht allgemeine Frage in Bezug auf zwei alternative Möglichkeiten z.B. bei der Erstellung eines PropertyBags.

Die eine Möglichkeit ist, von einem Dictionary abzuleiten, die andere ist ein Dictionary zu kapseln:

class PropertyBagDerived : Dictionary<string, string>
{
    public PropertyBagDerived() : base(StringComparer.OrdinalIgnoreCase) { }
}

class PropertyBagEncapsulated
{
    private Dictionary<string, string> _propertyBag = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);

    public Dictionary<string, string> GetAll
    {
        get { return _propertyBag; }
    }

    public string GetByName(string propertyName)
    {
        return _propertyBag[propertyName];
    }

    public void Add(string propertyName, string propertyValue)
    {
        _propertyBag.Add(propertyName, propertyValue);
    }
}

Verwenden kann ich sie annähernd gleich:

class Program
{
    static void Main(string[] args)
    {
        PropertyBagEncapsulated pbe = new PropertyBagEncapsulated();
        pbe.Add("Hello", "World");
        pbe.Add("Hi", "Ho");
        foreach (string s in pbe.GetAll.Keys)
            Console.WriteLine("{0} {1}",s,(pbe.GetAll)[s]);
        Console.WriteLine("{0}", pbe.GetByName("Hi"));

        PropertyBagDerived pbd = new PropertyBagDerived();
        pbd.Add("Hello", "World");
        pbd.Add("Hi", "Ho");
        foreach (string s in pbd.Keys)
            Console.WriteLine("{0} {1}", s, pbd[s]);
        Console.WriteLine("{0}", pbd["Hi"]);

        Console.ReadKey();
    }
}

Was ich bis jetzt sehe, wenn ich Vor- und Nachteile vergleiche ist Folgendes:

• Nachteil Kapseln: Mehr Implementierungsarbeit (wie man bereits sieht).
• Vorteil Kapseln: Mehr Kontrolle über das Dictionary (wenn erforderlich).
  Beim Ableiten verhält es sich genau anders herum.

Gibt es sonst noch wichtige Vor- oder Nachteile der Ansätze, die ich nicht sehe?
Was bevorzugt ihr? Und warum?

Danke im Voraus,
AtzeX

@talla, Michbeck1983, winSharp93:
Vielen lieben Dank für's Augen-Öffnen.
Macht wirklich Sinn, so wie es ist.

Edit:

Wo streicht VS überhaupt was rot an?

        static void Main(string[] args)
        {
            striiiiing s = "test";
            Console.WriteLine(s);
        }

Hier wird es schon rot 'unterkringelt', deswegen meine 'Verwirrung'.

Über 60 Views und keiner weiß es?

Das hätte ich nun echt nicht gedacht. 🤔

Hallo zusammen.

Ich habe folgenden Code:

using System;

namespace ConsoleApplication1
{
    class Program
    {
        static void Main(string[] args)
        {
            Console.WriteLine(foo("test"));
            Console.ReadKey();
        }

        static string foo(striiiiiiiing s)
        {
            return s.ToUpper();
        }
    }
}

Wie man sieht ist in der Definition der Methode "foo" der Datentyp des ersten Parameters falsch geschrieben.
Visual Studio (2008) meckert diese Stelle aber nicht an, unterstreicht es also nicht rot.

Kann mir jemand erklären warum?

Danke im Voraus,
AtzeX

Nun, auf Grund der Resonanz tippe ich mal darauf, dass das von Microsoft eher willkürlich so gewählt wurde und es keinen tiefsinnigen Grund dafür gibt. 🙂

Hallo zusammen.

Ich habe die Frage nicht komplett in den Betreff formulieren können, von daher der allgemeinere Titel.

Was ich eigentlich wissen möchte ist, warum Visual Studio das resultierende Projekt des "Windows Server" Templates auf "Windows Application" setzt und nicht auf "Console Application".

Der Vorteil, wenn ich es auf "Console Application" setze ist der, dass ich (entsprechende Prüfung vorrausgesetzt natürlich) den Dienst auch als 'normale' Konsolenapplikation ausführen kann.
Das ist prima zum testen des Projektes.

Nur warum steht es standardmäßig auf "Windows Application"?
Hat das andere Vorteile, die ich nicht sehe?

Gruß,
AtzeX