Hallo,

Nachdem es jetzt eine Weile gedauert hat (entschuldigt die Wartezeit), habe ich gute Nachrichten: die 15% Ermäßigung sind jetzt wieder verfügbar! Der neue Code lautet <aktueller Code siehe erster Beitrag> Viel Spaß also beim Schmökern!

Viele Grüße,
Andre

Hallo,

Wenn es wirklich so lange braucht würde ich es so machen, dass diese langwierige Verarbeitung asynchron läuft. Das heißt, der Benutzer stößt den Prozess mit einem Klick auf einen Button oder Link an und bekommt dann direkt eine "Bitte-Warten"-Seite zu sehen die sich regelmäßig aktualisiert (z.B. alle 5 Sekunden). Sobald das Ergebnis feststeht wird die Ergebnisseite gezeigt.

Technisch ließe sich das z.B. so lösen, dass du die Anfrageparameter in eine Datenbankschreibt und ein Windows-Service diese Anfragen im Hintergrund "abarbeitet". Wenn das Ergebnis verfügbar ist, wird es wieder in eine Datenbankgeschrieben und ein bestimmtes Flag gesetzt, sodass die Webseite weiß, dass die Daten nun verfügbar sind. Alternativ können Webanwendung und Service auch direkt über remoting kommunizieren.

Damit hast du auch mehr Kontrolle, wie du auf mehrere Anfragen vom selben Client reagierst. Z.B. kannst du festlegen, dass nur eine Anfrage pro IP gleichzeitig gestattet ist. Bei einer zweiten Anfrage erhält der Nutzer die Möglichkeit, den aktuellen Auftrag abzubrechen.

Grüße,
Andre

Ach ja, String.Contains gibt es ja auch noch. Aber erst seit .NET 2, da ist das noch nicht zu mir durchgedrungen 😉

Hallo,

Siehe String.IndexOf, für komplexere Überprüfungen der E-Mail Adresse empfehlen sich Reguläre Ausdrücke (System.Text.RegularExpression)

Grüße,
Andre

Hallo,

Ich denke, dass die Vorstellung, reduzierte Preise würden Raubkopien einschränken, ein ziemliches Wunschdenken ist. Dem Raubkopierer an sich dürften die Preise egal sein. Ein Programm/Spiel/etc. aus einem Netzwerk herunterzuladen ist immer die einfachere und günstigere Variante als das lizensierte Original aus dem Handel. Im Gegenteil: würde die Software billiger werden, könnten Raubkopierer so argumentieren, dass der finanzielle Schaden durch Raubkopien doch ebenfalls geringer geworden ist. (Ob das auch für Musik gilt, weiß ich nicht. Sind die Kunden von iTunes und co ehemalige Raubkopierer oder einfach Kunden, die den neuen Vertriebsweg schätzen? Ich zumindest zähle zu letzteren)

Das generelle Problem bei Raubkopien ist die leichte Verfügbarkeit, die fehlenden Konsequenzen und - und das ist mMn der wichtigste Punkt - das fehlende Bewusstsein für die Unrechtmäßigkeit der Tat. Ich bin der letzte, der jeden Raubkopierer in den Knast stecken will, da muss man schon differenzieren und gerecht bleiben. Gegen die leichte Verfügbarkeit kann man wohl kaum etwas machen. In Sachen Bewusstsein tut sich in der Gesellschaft schon ein wenig(!), denke ich. Allerdings hat Software das inhärente Problem, dass sie beliebig teilbar ist, ohne dass sie weniger wird. Man nimmt also physisch gesehen niemandem etwas weg. Ein geklautes Auto ist ein viel offensichtlicherer Diebstahl.

Als Konsequenz bleibt den Entwicklern wohl nur der Versuch, die technischen Hürden anzuheben, die es für eine Raubkopie zu überwinden gilt. Leider geschieht das manchmal (oder viel zu oft) zu lasten der ehrlichen Dummen.

Übrigens kostet ein Vista Home Premium als SB Version inkl Versand unter 100€, das halte ich nicht zu viel. Selbst die Ultimate Edition ist für ~170 € zu bekommen.

Grüße,
Andre

Hallo,

Schlagt mich jetzt nicht, wenn ich Unsinn erzähle, aber ich habe da noch so eine Geschichte im Kopf, dass .NET Controls, die per "Remove" entfernt wurden in eine unsichtbare "Parking Form" verschiebt und sie somit im Speicher bleiben. Du solltest also auf jeden Fall noch Dispose() auf das Control anwenden, dass du entfernst. Ob das mit den Parking Forms noch so ist, weiß ich nicht, schaden kann ein Dispose aber nicht.

Grüße,
Andre

http://forums.microsoft.com/MSDN/ShowPost.aspx?PostID=249224&SiteID=1

Hallo,

Auch wenn das normalerweise immer herbivore übernimmt: wir haben eine schöne FAQ-Sektion, in der man Beiträge wie [FAQ] NullReferenceException: Der Objektverweis wurde nicht auf eine Objektinstanz festgelegt findet.

Beim nächsten mal also erst mal schauen, was wir schon so alles "auf Lager" haben 😉

Viele Grüße,
Andre

Hallo,

Mir sind als erstes zwei Begriffe in den Kopf gekommen: State-Pattern und Command-Pattern.

Vielleicht findest du da das, was du sichst (dein Ansatz scheint auf dem ersten Blick einem State-Pattern nicht ganz fern zu sein

Viele Grüße,
Andre

P.S.: zur Erklärung: die verschiedenen States könnten dann das selektierte Tool sein. Die Commands mögliche Befehle. In diesem Zusammenhang könnte ich mir auch eine Verwendung des Visitor-Patterns vorstellen, indem du die Commands als Visitor implementierst, die je nach Kombination "Tool"<->"Objekt, mit dem das Tool verwendet wird" die richtige Aktion (oder eben nichts) ausführen.

Ich sage nicht, dass man sich nicht beschweren darf. Ich möchte nur vor blinder Panikmache absehen.

Hallo,

Siehe Request.UserHostAddress

Grüße,
Andre

Hallo,

Wie auch so oft heißt es auch hier: abwarten und Ruhe bewahren. Nichts wird so heiß gegessen wie es gekocht wird. Zunächst sollte Windows auch nur auf dem Computer laufen, auf dem es als erster aktiviert wurde. Davon ist MS auch wieder heruntergegangen. Die Aktivierungspolitik sieht wieder ähnlich aus wie bei XP: begrenzte Anzahl Aktivierungen pro Jahr, danach "Sicherheits"-Frage bei der MS-Hotline. ("Auf wie vielen Rechnern haben sie das Produkt gleichzeitig installiert?" - "Öhm.. vier?" - ZONK).

Wie die Praxis wg. der Remote-Abschaltung aussieht, wird sich zeigen. MS wird kaum "einfach so" irgendein Windows abschalten (werden sie auch rechtlich kaum dürfen, da man eine Lizenz zur Nutzung erworben hat). Auch eine EULA-Klausel à la "MS behält sich das Recht vor, Windows teilweise oder vollständig abzuschalten" halte ich für juristisch nicht haltbar.

Aber mal eine andere Anekdote, die mich ärgert: ich habe noch eine WinXP Home System Builder-Lizenz inkl Upgrade-Coupon auf Vista. Nur soll mich das Upgrade knappe 90 Euro kosten (inkl. Versand). Da kauf ich mir doch lieber eine "eigenständige" neue Vista SB-Version für das gleiche Geld und habe dann zwei "Windowse". Für Retail-Kunden ist so ein Vista-Upgrade mit 17 Euro irgendwas ja eine attraktive Sache, für OEM Kunden aber eine Farce.

Grüße,
Andre

Der Konstruktor führt lediglich eine elementweise flache Kopie durch. Die Exemplare, die in der ersten Liste vorkommen, sind die gleichen wie die in der Kopie. Eine Änderung wirkt sich also "in beiden Listen" aus.

Grüße,
Andre

Session-Variablen 😉

Was geht denn genau "verloren"? Welchen Session-Modus verwendest du (inproc, stateserver, sqlserver)? Ist die Sliding-Expiration eingeschaltet? Wie hoch ist das Session-Timeout?

Grüße,
Andre

Hallo,

Woher willst du denn wissen, ob diese Stelle im Code wirklich performancekritisch ist? Wie oft wird sie angerufen? Wie sind die gemessenen Laufzeiten in der Praxis?

Mal ehrlich, du kannst unmöglich so ein pauschales Urteil abgeben. Die wenigsten Anwendung werden in der Praxis von solchen "Kinkerlitzchen" wie Reflection gebremst. Datenbankabfragen sind in der Regel die (wesentlich!) größeren Brocken.

"Im Grunde" könnte man das ganze auch in hochoptimiertem ASM schreiben. Aber ich verzichte doch lieber auf eine knappe (sprichwörtliche) Millisekunde, wenn ich dafür den Komfort und die Möglichkeiten von Reflection erhalte. Außerdem erspare ich mir einige potenzielle Bugs. Das ist besser für die Nerven.

Viele Grüße,
Andre

Hallo,

Mit Strings ist das so eine Sache. Wenn z.B. dein "HasChanges" umbenannt wird in "IsDirty" könnte das womöglich Probleme geben. Ich finde, hier wäre ein guter Anwendungsfall für ein Attribut. Entweder sehr allgemein ("Skip" o.ä.) oder aber - denn es geht ja hier wohl um mehr - etwas spezifischer (z.B. "Volatile" oder "NonPersistent" oder "Unobserved" etc. . ).

Hier mal ein Beispiel mit einem eigenen "NoChangeTracking" Attribut:

[AttributeUsage( AttributeTargets.Property, Inherited = true, AllowMultiple = false )]
public class NoChangeTrackingAttribute : Attribute {
}

public class UserConfiguration {

    [NoChangeTracking]
    public bool HasChanges {
        get {
            foreach( PropertyInfo propertyInfo in this.GetType().GetProperties() ) {
                if( !propertyInfo.CanRead ||
                    Attribute.GetCustomAttribute( propertyInfo, typeof( NoChangeTrackingAttribute ) ) != null ) {
                    continue;
                }
                object value = propertyInfo.GetValue( this, null );
                //...
            }
            //...
        }
    }
}

Es dürfte logisch sein, dass du mit den Attributen sehr viel flexibler bist.

Viele Grüße,
Andre

Wäre nicht das erste Projekt mit überraschend hohen TCO 😉

Ich bin mit meiner Freundin etwa 5 1/2 Jahre zusammen. Was die Zukunft bringt, weiß man nie. Aber ich bin da guter Dinge.

Grüße,
Andre

Soweit ich das sehe, ist die Klasse System.Windows.Forms.Screen auch für CF 2.0 Verfügbar. Die sollte dir weiterhelfen.

Grüße,
Andre

Es scheint alles wieder im grünen Bereich zu sein. Die Auslastung ist wieder auf gewohntem Niveau. Hoffen wir, dass das gestern nur ein "Ausrutscher" war.

Grüße,
Andre

Ein interessanter Bericht zum Thema Zeitgeber

Viele Grüße,
Andre

Hallo Community,

Unser Webserver ist in der letzten Stunde ungewöhnlich stark ausgelastet. Es kann daher zu Verzögerungen und zeitweisen Ausfällen kommen. Wir beobachten die Sachlage und möchten euch um Geduld bitten.

Viele Grüße,
Andre

Original von Merlin001969
Ich bin der der sich mit solchen Sachen im nachhinein rumschlagen muss.

Mein Beileid, das kenne ich 😉

Grüße,
Andre

Ich empfehle übrigens PageMethods für "saubere" und stabile Redirects.

Grüße,
Andre

Ich habe mir dafür einfach code-snippets geschrieben, siehe Anhang. Die Datei im .zip-Archiv gehört nach %EIGENE_DATEIEN%\Visual Studio 2005\Code Snippets\Visual C#\My Code Snippets

Jetzt kannst du einfach innerhalb der Seite z.B. Page_PreInit + Tab eingeben und der Rumpf wird eingefügt. Die Datei enthält snippets für alle Page-events.

Grüße,
Andre

Hallo,

Ich gehe zunächst einmal davon aus, dass du weißt, dass ein varchar nicht unbedingt der optimale Datentyp ist, um Zahlen zu speichern.

Zu deinem Problem: der SQL-Server erwartet einen Punkt als Dezimaltrennzeichen (also 123.456 statt 123,456), man kann ihm meines Wissens nach auch kein anderes Trennzeichen beibringen, da er aus ANSI-SQL basiert.

Das bedeutet für dich:
a) die Zahlen in Bruttogesamt müssen mit einem Punkt als Dezimaltrennzeichen vorliegen - oder - du musst die Daten "von Hand" konvertieren mit REPLACE(Bruttogesamt, ',', '.')
b) die Zahlen, mit denen du vergleichst (hier: 1,00 und 50,00) müssen mit einem Punkt als Dezimaltrennzeichen vorliegen
c) Es ist nicht notwendig, die Zahlen, mit denen du vergleichst, in Anführungszeichen zu setzen.

SELECT 
Convert(float, REPLACE(Rechnung.Bruttogesamt, ',', '.')) AS Betrag
FROM Rechnung 
Where 
(Convert(float,REPLACE(Rechnung.Bruttogesamt, ',', '.')) >= 1.00
AND 
Convert(float,REPLACE(Rechnung.Bruttogesamt, ',', '.')) <= 50.00)

Grüße,
Andre

Eigentlich sollte beides Funktionieren. Hier eine Übersicht verschiedenster Möglichkeiten, um das PreInit-Event zu abonnieren:

public partial class _Default : System.Web.UI.Page {

    public _Default() {
        // Möglichkeit 1a: event manuell abonnieren (anonymer Delegat)
        PreInit += delegate { 
            /*
             *  Hier dein Code
             */
        };

        // Möglichkeit 1b: event manuell abonnieren (eigener Eventhandler)
        PreInit += HandlePreInit;
    }

    void HandlePreInit(object sender, EventArgs e) {
        /*
         * Hier dein Code
         */
    }
    
    // Möglichkeit 2: OnPreInit überschreiben
    protected override void OnPreInit( EventArgs e ) {
        base.OnPreInit( e );
        /*
         * Hier dein Code
         */
    }

    // Möglichkeit 3: automatisches Event-Wireup (erfordert AutoEventWireup="true")
    protected void Page_PreInit(object sender, EventArgs e) {
        /*
         * Hier dein Code
         */
    }
}

Die bevorzugte Möglichkeit ist Möglichkeit 3 (da automatisch), dann 1, im Notfall 2 (fehleranfällig: base.OnPreInit nicht vergessen!).

Grüße,
Andre

Der bevorzugte Produktionsserver ist IIS (Internet Information Server) von Microsoft, welcher bei Windows XP Professional, Windows Server 2003 und ab Windows Vista Business verfügbar ist. Visual Studio/Web Developer bietet jedoch auch einen eingebauten Entwicklungsserver, mit dem man Webseiten auch auf XP Home entwickeln und testen kann.

Grüße,
Andre

Nein, der PK ist exakt der der generalisierten Tabelle und sollte entsprechend auch kein Autowert (Identity) sein.

Die PKs in der spezialisierten Tabelle sind in jedem Fall "unique" (da eben PK) , sodass sich jede Reihe einer spezialisierten Tabelle eindeutig über diesen PK erreichen lässt.

Grüße,
Andre

Ein reiner 3D-Modeller dürfte in C# von den Randbedingungen her (Geschwindigkeit etc.) kein Problem sein. Die größte Arbeitslast liegt zunächst einmal bei der grafischen Wiedergabe, und dort kann man mittels Direct3D oder OpenGL die Grafikkarte das Gros der Arbeit übernehmen lassen. Wenn man bedenkt, dass es kommerzielle Spiele gibt, die auf .NET basieren, dürfte einleuchten, dass ein Modeller machbar ist - die zu bewältigende Arbeit ist schließlich viel spezialisierter und überschaubarer als ein Spiel (Grafik, Sound, Physik, KI, Netzwerk etc.).

Wenn es um das aufwändige (nicht-realtime) Rendern des Modells - also Numbercrunching par excellence - geht, könnte ich mir vorstellen, dass eine "naive" C# Implementierung zunächst Performanceprobleme haben kann, primär durch die eingebauten Sicherheitschecks (Arraygrenzen o.ä.). sollten solche Probleme nachweislich auftreten, lassen sich die kritischen Codeteile noch immer mit unsafe-Code und C++/CLI-Interop "aufpäppeln".

Die pauschale Aussage "Also gegenüber C# liegt C++ deutlich näher an der Maschine und damit ist ein 3D-Modeller in dieser Sprache auch um einiges schneller." halte ich für fragwürdig. a) Was ist "um einiges schneller"? b) Wie viel Last liegt überhaupt auf dem Prozessor, sprich: die Runtime (Stichwort OpenGL, D3D, siehe oben)? c) Zur Laufzeit ist ein in C++ geschriebenes Programm nicht "maschinennäher" als ein Programm in C#. Die kritischen Faktoren sind hier eher der JIT-Compiler (Optimierung, ggf. für die Architektur) und die Art, wie die Operationen in C# ausgedrückt werden (siehe unsafe-Code). Und wie gesagt spricht wenig dagegen, entsprechend sensible Teile als hochoptimierten, nativen C++-Code auszulagern und mittels IJW-Interop einzubinden.

Fazit: ein reiner Modeller dürfte technisch auch in C#-only problemlos machbar sein, doch auch aufwändigere Module (Renderer etc.) lassen sich mit den nötigen Kniffen ebenfalls realisieren.

Grüße,
Andre

Hallo,

Wenn du willst, dass die Assemblies im "Verweis hinzufügen"-Dialog unter ".NET" auftauchen, musst du dies explizit in der Registry angeben. Besagter Dialog zeigt nämlich nicht - wie man vermuten könnte - den GAC an.

Siehe http://blogs.msdn.com/astebner/archive/2005/11/28/497693.aspx

Grüße,
Andre

Edit: besserer Link

Hallo,

Um doch noch was sinnvolles zu sagen: um ein Objekt mittels foreach durchlaufen zu können, muss es nicht zwangsweise von InternalDataCollectionBase abgeleitet sein.

Die Bedingungen für "foreach-Kompatibilität" sind eigentlich extrem gering:

1. Das Objekt muss eine parameterlose Methode GetEnumerator() haben, die ein Objekt zurückgibt
2. Dieses Objekt (der Enumerator) muss mindestens die Methode public bool MoveNext() und die Property public TypEinesElements Current { get; } implementieren.

Die Semantik von MoveNext und Current ist in der Doku für IEnumerator nachzulesen.

Um diese Bedingungen sehr explizit zu erfüllen, kann man für das Collection-Objekt die Schnittstelle IEnumerable (bzw. IEnumerable<T>) und für den Enumerator IEnumerator (respektive IEnumerator<T>) implementieren - zwingend nötig ist das nicht (In Anbetracht der Tatsache, dass es häufig Methoden gibt, die ein IEnumerable als Argument erwarten, ist es aber zu empfehlen.)

Hier mal ein Beispiel für eine einfache indizierte Collection, die mit foreach durchlaufbar ist (ohne Implementierung von IEnumerable/IEnumerator).

Die Collection:

/// <summary>
/// Einfache indizierte Collection für Elemente vom Typ <typeparamref name="T"/>
/// </summary>
/// <typeparam name="T">Typ eines Elements</typeparam>
public class MyCollection<T> {
    private const int InitialSize = 10;
    private T[] elements = new T[InitialSize];
    private int count = 0;

    /// <summary>
    /// Gibt die Anzahl der Elemente zurück
    /// </summary>
    public int Count {
        get { return count; }
    }

    /// <summary>
    /// Gibt die maximale Anzahl der Elemente zurück, die die Collection
    /// aufnehmen kann, ohne den internen Puffer zu vergrößern.
    /// </summary>
    public int Capacity {
        get { return elements.Length; }
    }


    /// <summary>
    /// Gibt das Element beim <paramref name="index"/> zurück.
    /// </summary>
    /// <param name="index">Index des Elements</param>
    /// <returns>Das Element am gegebenen <paramref name="index"/></returns>
    /// <exception cref="ArgumentOutOfRangeException">
    /// Der Index ist ungültig.</exception>
    public T this[int index] {
        get {
            if( index < 0 || index >= count ) {
                throw new ArgumentOutOfRangeException( "index" );
            }
            return elements[index];
        }
    }
    
    /// <summary>
    /// Fügt der Collection ein Element hinzu
    /// </summary>
    /// <param name="element"></param>
    public void Add(T element) {
        if(count >= Capacity) {
            IncreaseCapacity();
        }
        elements[count++] = element;
    }
    
    /// <summary>
    /// Gibt einen Enumerator für die Collection zurück
    /// </summary>
    /// <returns></returns>
    public MyCollectionEnumerator<T> GetEnumerator() {
        return new MyCollectionEnumerator<T>( this );
    }

    /// <summary>
    /// Verdoppelt die Kapazität des internen Puffers.
    /// </summary>
    private void IncreaseCapacity() {
        // array vergrößern
        T[] newElements = new T[this.elements.Length * 2];
        Array.Copy( this.elements, newElements, this.elements.Length );
        this.elements = newElements;
    }
}

Der Enumerator:

/// <summary>
/// Enumerator für <see cref="MyCollection{T}"/>
/// </summary>
/// <typeparam name="T">Typ eines Elements.</typeparam>
public class MyCollectionEnumerator<T> {
    private MyCollection<T> collection;
    private int index = -1;

    internal MyCollectionEnumerator( MyCollection<T> collection ) {
        this.collection = collection;
    }

    public bool MoveNext() {
        index++;
        return index < collection.Count;
    }

    public T Current {
        get {
            return collection[index];
        }
    }
}

Und hier ein Test um die "foreach-Kompatibilität" zu zeigen (NUnit):

[TestFixture]
public class CollectionTests {

    [Test]
    public void Enumerate() {
        MyCollection<int> collection = new MyCollection<int>();
        for( int i = 0; i < 5; ++i ) {
            collection.Add( i );
        }
        int[] readItems = new int[collection.Count];
        int index = 0;
        foreach( int i in collection ) {
            readItems[index++] = i;
        }
        // enumerator sollte alle Elemente zurückgegeben haben.
        Assert.AreEqual( new int[] { 0, 1, 2, 3, 4 }, readItems );
    }
}

Ansonsten ist die Frage von herbivore natürlich berechtigt: ist es überhaupt zwingend nötig, eine eigene Collection zu schreiben?

Viele Grüße,
Andre

Hallo,

Ich muss mich direkt für den Spam entschuldigen, aber...

Original von Curse4Life
Nun habe ich diese Collection von InternalDataCollectionBase abgelitten

Geil 😁

Nichts für ungut - ich konnte nicht widerstehen 😉

Viele Grüße,
Andre

P.S. Um diesem Post doch noch einen Sinn zu geben: das Partizip Perfekt Passiv zu "ableiten" ist "abgeleitet".

Hallo MinusBrain,

Wir gehen der Sache nach. Sobald wir mehr wissen, geben wir hier Bescheid.

Viele Grüße,
Andre

Die Sprache hat einige interessante Features, die man sich auch in C# wünschen würde (z.B. covariante Rückgabetypen), andererseits scheint sie an einigen Stellen zu sehr der "Featuritis" verfallen zu sein. Die Sprache wird dadurch ziemlich aufgebläht mit allerlei Features von zweifelhaftem Wert (mixins, init).

Sicherlich grundsätzlich eine interessante Sprache, jedoch mit zweifelhaftem praktischem Wert. Als aufgebohrte C++ Variante sicherlich einsetzbar, jedoch bei weitem nicht so RAD-fähig wie C#. Dafür nimmt D einfach zu wenig die Komplexität von C++ weg.

Grüße,
Andre

Hallo,

Um die Dateien bzw. Teile davon in den Speicher (byte-Arrays) zu laden wird "ganz normales" Datei I/O verwendet. Siehe dazu auch [Tutorial] Alles über Dateien 2.0

Für das Ver- und Entschlüsseln solltest du dir mal die CryptoStream-Klasse in Verbindung mit den anderen Klassen im Namespace System.Security.Cryptography anschauen.

Allgemein gibt es viele Tutorials zur Verschlüsselung unter .NET, z.B.
http://www.codeproject.com/csharp/using_cryptostream.asp
http://www.codeproject.com/dotnet/DotNetCrypto.asp
http://www.codeproject.com/useritems/Cryptography_MD5_TriDES.asp

Grüße,
Andre

Der Unterschied zwischen BeginExecuteNonQuery und ExecuteNonQuery ist, dass ersteres asynchron läuft (die Methode kehrt sofort zurück, die Query wird im Hintergrund ausgeführt) während zweiteres synchron ausgeführt wird (die Methode kehrt erst dann zurück, wenn die Query vollständig ausgeführt wird).

Ganz allgemein solltest du dir klar machen, dass der DataAdapter ein Hilfsobjekt ist, um den Inhalt von Datenbanktabellen mit einem DataSet im Speicher zu synchronisieren. Wie du in der Dokumentation lesen kannst (und solltest), sind DataSets Repräsentationen der Daten der Datenbank im Speicher. DataAdapter stellen den Austausch der Daten zwischen DataSet und Datenbank sicher. DataAdapter verwenden für diesen Austausch die entsprechenden Select, Insert, Update und Delete-Queries in Form von SqlCommands (bzw. eine andere IDbCommand Implementation je nach Provider).

Um lediglich ein Insert-Statement loszulassen, reicht auch ein einfaches SqlCommand.

Grüße,
Andre

Hallo KaNe,

Ich denke, dass dir hier grundsätzlich jeder viel Erfolg mit deinem Projekt wünscht. Allerdings solltest du die rechtliche Frage wirklich nicht auf die leichte Schulter nehmen. Klar kann es sein, dass du niemals Reaktionen seitens der Rechteinhaber erhalten wirst. Ebenso ist es aber möglich, dass sie zu der Sorte gehören, die sehr penibel auf die Wahrung ihrer Rechte achten. Denn auch ein kostenloses Hobbyprojekt kann geschäftsschädigend sein: sei es durch eine gewollte oder ungewollte Verunglimpfung des geschützten Produkts oder durch eine Konkurrenzsituation zu eigenen Produkten (wenn z.B. die Rechteinhaber ein vergleichbares Produkt selbst entwickeln).
Schlussendlich verschaffst du dir einen Vorteil (das Spiel gewinnt durch die Platzierung im Stargate-Universum an Attraktivität z.B. bei Fans der Serie) auf Kosten der Rechteinhaber. Diese haben viel Geld ausgegeben, um das Stargate Franchise aufzubauen und zur Popularität zu verhelfen.

Und dir sollte eines klar sein: wenn du auf die "richtige" Gegenseite stößt, blüht dir ggf. mehr als eine E-Mail à la "bitte nehmen sie das Projekt vom Netz". Der Rechteinhaber kann dich u.U. direkt abmahnen, d.h. dir entstehen womöglich umgehend (saftige) Kosten.

Wie gesagt, ich will dein Projekt nicht schlecht reden - im Gegenteil: es wäre doch schade, wenn alle Mühen umsonst gewesen wären wegen einer Rechtsverletzung.

Viele Grüße,
Andre

Eine ASP.NET Webanwendung wird vom ASP.NET workerprocess ausgeführt (unter WinXP ist das aspnet_wp.exe, unter Win2003 w3wp.exe), dieser läuft standardmäßig unter dem Benutzeraccount ASPNET (WinXP) bzw. NETZWERKDIENST (Win2003). Du kannst über die web.config einer Webanwendung jedoch dem Workerprozess für deine Anwendung eine andere Identität geben (Impersonation).

Siehe http://weblogs.asp.net/kwarren/archive/2003/09/17/27971.aspx

Grüße,
Andre

Wenn du Nutzername und Passwort angibst bzw. Trusted Connection auf false setzt, hast du aber keine Windowsauthentifizierung sondern SQL Server Authentifizierung, daher klappt der Loginversuch nicht. Für die Windowsauthentifizierung wird die Identität des ausführenden Prozesses verwendet. Der Prozess, der sich beim Server anmelden will, muss daher unter den entsprechenden Windows-Account ausgeführt werden.

Grüße,
Andre

Wie lautet denn der Connection String? Er sollte eines der folgenden Formate haben:

Data Source=myServerAddress;Initial Catalog=myDataBase;Integrated Security=SSPI; oder
Server=myServerAddress;Database=myDataBase;Trusted_Connection=True;

Siehe auch ConnectionStrings.com
Grüße,
Andre

Was sagt die Fehlermeldung?

Grüße,
Andre

Hallo,

Zum Verändern des GAC benötigt man Admin-Rechte. Als Admin steht es dir natürlich frei, dein System zu schrotten wie es dir beliebt. Als eingeschränkter Nutzer könntest du genauso wenig sicherheitsrelevante Assemblies aus dem GAC löschen wie du Sicherheitssoftware deinstallieren/löschen kannst. Ich sehe hier kein .NET spezifisches Sicherheitsrisiko.

Grüße,
Andre

Basteln mit Microsoft: http://office.microsoft.com/training/Training.aspx?AssetID=RP010951191031&CTT=6&Origin=RC010950981031

Grüße,
Andre

DataSet.ReadXml
DataSet.ReadXmlSchema

Klar ist das machbar, solange du dich an die Regeln von XML hälst, z.B. dass eine Datei nur ein Root-Element haben kann.

<?xml version="1.0" encoding="utf-8"?>
<Sections>
  <Section name="Testsection">
    <Object name="Testobject">
      <Eigenschaft>Test</Eigenschaft>
    </Object>
    <Setting>
      <Testname>Testwert</Testname>
    </Setting>
    <Setting>
      <Testname2>Testwert2</Testname2>
    </Setting>
  </Section>
</Sections>

Mit den entsprechenden Query-Techniken lassen sich nun auch gezielt Objekte lesen, z.B. liefert der XPath-Ausdruck //Object[@name='Testobject'] alle Objekte mit Namen Testobject.

Grüße,
Andre

Ich glaube, er will sie bloß leeren, nicht löschen.

"DELETE FROM MyTable" bzw. "TRUNCATE TABLE MyTable" - siehe T-SQL Doku!

Grüße,
Andre

Hm, versuche mal, zunächst das Projekt zu bereinigen.

Grüße,
Andre

P.S.: "Meus documentos"?

Du kannst lediglich mittels using lokal für eine Datei eine Art Typedef erstellen:

using System.Collections.Generic;


namespace Foo.Bar {

  using AppointmentMap = Dictionary<string, List<AppointmentItem>>;

  class XYZ {
    AppointmentMap appointments = new AppointmentMap();

   ...
  }
}

Grüße,
Andre

Wichtig für automatisierte Tests ist, dass sie wiederholbar sind. Das setzt voraus, dass die Umstände gleich bleiben. Wenn du eine Methode testen willst, die ein Cookie verarbeitet, musst du das zu testen Cookie entsprechend selbst anliefern (z.B. als Parameter).
Wenn du Unit-Tests mit Datenbankeinfluss machen willst, müssen alle Umstände, die auf das Ergebnis Einfluss haben können zunächst konstant gemacht werden. Im schlimmsten Fall bedeutet das, dass die Datenbank für die Unittests jedes Mal neu erstellt werden muss. In einfachen Fällen reicht es, gemachte Veränderungen nach dem Test wieder rückgängig machen zu lassen.
Wenn eine Methode von einer Konfiguration abhängig ist, muss du sie ihr explizit geben, ggf. vorgaukeln.

Wenn das nicht möglich ist, kann man mMe keine automatisierten Tests durchführen. Dann helfen nur gut dokumentierte Szenarien, die man dann von Hand ausführt.

Zum Thema Unit Testing und Datenbanken gibt es übrigens Material im Netz, googlen nach "Unit testing database" bringt dich da weiter.

Grüße,
Andre