Du kannst jeder Variable direkt einen Wert zuweisen:

Class c1 = new Class();
Class c2;
c2 = c1;

Das kannte ich noch gar nicht. Hat das Vorteile gegenüber Matches?

Du hast mich verstanden 👅

Beim zweiten Regex aber die Matches-Methode verwenden.

Hol dir zuerst die Klammer und danach mit Regex.Matches die einzelnen Parameter.

Solange religiöse Gruppen die Macht haben mein Leben zu beeinflussen (z.B. in Ethikräten) lohnt es sich dagegen zu demonstrieren.

http://technet.microsoft.com/de-de/sysinternals/bb896646.aspx

Unter Windows 2000 und höher gibt es keine Treiberkomponente
[...]
Unter Windows 2000 und höher verwendet Diskmon die Kernel-Ereignisablaufverfolgung. Die Ereignisablaufverfolgung ist im Microsoft Platform SDK dokumentiert. Das SDK enthält Quellcode zu TraceDmp, auf dem DiskMon basiert.

Pack die PBs in ein Array.

Welche Unterschiede?

Hallo DeZio,

scheinbar hast du die Regex Regeln noch nicht so ganz verstanden. Da hilft nur Üben und Tutorials lesen. Helfen wird dir dabei sicher der On-the-fly Regex-Tester: Regex-Lab.

Das folgende Pattern passt zwar noch nicht ganz zu deinem Code (bzw. umgekehrt), ist aber ein Ansatz.

Was per Definition der Fakultät eigentlich unmöglich ist.

Hättest du auf den Link geklickt wüsstest du es besser.

Auf Wunsch bin ich nochmal die Bibliothek durchgegangen und habe geschaut, wo ich Konstrukte von C# 3.0 eingesetzt habe und wie man sie durch "älteren" Code ersetzen kann.

Auf jeden Fall werden die Spracherweiterungen nochmal in [Artikel] Spracherweiterungen in C# 3.0 von Noodle erklärt.

Automatische Eigenschaften:
Das Ersetzen sollte kein Problem sein.

Container/AdditionElement.cs
Container/MultiplicationElement.cs
Formulas/BaseFunction.cs
Formulas/Constant.cs
Formulas/Division.cs
Formulas/Number.cs
Formulas/Power.cs
Formulas/Variable.cs

Objektinitialisierer:
Genauso hier.

Formulas/Addition.cs
Formulas/BaseFunction.cs
Formulas/Constant.cs
Formulas/Division.cs
Formulas/Multiplication.cs
Formulas/Power.cs

Lambda Expressions:

return elements.All(el => el.Formula.Simplified);
Wird zu:
foreach (AdditionElement element in elements)
{
    if (!element.Formula.Simplified)
        return false;
}
return true;

Formulas/Addition.cs
Formulas/Multiplication.cs
Formulas/Power.cs

LINQ Abfragen:

//Formulas/Addition.cs (Line 422)
//---------------------------------------------
// x + x => 2*x
//---------------------------------------------
var noneMultiplications = from element in elements
                          where !(element.Formula is Multiplication)
                          group element by element.Formula.GetHashCode() into g
                          select g;
                          
//Formulas/Division.cs (Line 183)
int length = numeratorLines.Union(denominatorLines).
                    OrderByDescending(l => l.Length).
                    First().Length;

In diesem Fall ist das Ersetzen leider nicht so trivial. Wenn ihr's selber machen wollt wünsch ich euch schon mal viel Spaß 😉. Einen guten Ansatz bietet hier aber herbivores Hilfreiche Iteratoren / Improving Foreach .

Formulas/Addition.cs
Formulas/Division.cs
Formulas/Multiplication.cs

Vereinzelt habe ich auch Implizit typisierte lokale Variablen benutzt.

Formula 0.1

Formula ist eine Bibliothek die ich vor einiger zeit geschrieben habe.
Sie ermöglicht es Formeln zu Parsen, vereinfachen zu lassen und abzuleiten.
Weiter besteht die Möglichkeit die Formeln als Ascii ausgeben zu lassen.
Die Bibliothek und die Beispielanwendungen wurden mit .net 3.5 erstellt.

Hab mal einen Formelparser geschrieben, der parst, vereinfacht und ableiten kann. Wenn Interesse besteht lad ichs mal hoch.

Schau dir mal alle Überladungen von OpenSubKey an.

Mit Type ist aber nicht ein beliebiger Typ, sondern System.Type gemeint.

Hilfreiche Iteratoren / Improving Foreach

Stichwort: Shuffle

Visual Studio 2008

Meine Erlaubnis hast du 😉

http://www.codeproject.com/KB/system/globalsystemhook.aspx

Herr Test.(.*?) Rom
Mit der Option Singleline

For und ein Array:

int dezimal = 4;
int[] dual = new int[sizeof(int) * 8];
for (int i = dual.Length - 1; i >= 0; i--)
{
    dual[i] = dezimal % 2;
    dezimal /= 2;
}

int dezimal = 5;
string dual = "";
while(dezimal > 0)
{
    dual = dezimal % 2 + dual;
    dezimal /= 2;
}

Frohe Weihnachten

Sieht echt gut aus 👍

static void RemoveLastChar()
{
    if (Console.CursorLeft > 0)
    {
        Console.CursorLeft--;
        Console.Write(' ');
        Console.CursorLeft--;
    }
    else
    {
        Console.CursorTop--;
        Console.CursorLeft = Console.BufferWidth - 1;
        Console.Write(' ');
        Console.CursorTop--;
        Console.CursorLeft = Console.BufferWidth - 1;
    }
}

Diese Aussage ist einfach nur sehr euphemistisch.
D?
Die Programmiersprache D
Die sprache D

Ist es legal die Links zu den alten Büchern zu posten, wenn sie auf den entwickler-press Webspace verweisen?

Original von tööö
Da sollte sich dann automatisch der Adventskalender öffnen g

NoScript > all 😜

Original von Peter Bucher
Die Url steht zwei mal in diesem Thread 🙂

Ich muss blind sein, aber ich finds nicht 😁
Die Url hab ich schon, aber auf der Seite find ich nichts.

Wo?

Ich würds eher bevorzugen, wenn wenigstens eine Exception geworfen würde. So wies jetzt ist gibt's ja echt keinen Anhaltspunkt, wenn man auf der Fehlersuche ist.

Eben nicht.

partial class Program
{
    partial void testPartial();
    
    static void Main(string[] args)
    {
        Program p = new Program();
        p.testPartial();
    }
}

//partial class Program
//{
//    partial void testPartial()
//    {
//        Console.WriteLine("Test");
//    }
//}

Wird ohne Warnung kompiliert.

Na stell dir z.B. vor du hast eine größere Klasse an denen mehrere Leute arbeiten. Es war so angedacht, dass die Funktion saveData die Daten z.B. in eine Datenbank schreibt. Am Ende wird die Klasse zusammengeführt und man stellt fest, dass merkwürdigerweise nichts passiert. Hm der Compiler zeigt keine Fehlermeldung, ja nicht einmal eine Warnung, an und saveData wird auch an den richtigen Stellen aufgerufen. Wo ist der Fehler?

Schande über mich 😁

Hi,

kennt ihr schon die neuen Auto-Implemented Properties von C# 3.0?
Im ganzen LINQ-Trubel scheint mir diese geniale Neuerung verloren gegangen zu sein.
Ich weiß ja nicht wie es euch geht, aber die sinnlosen getter und setter, die nicht mehr Code beinhalteten als das zurückgeben und festlegen des eigentlichen Feldes, sind mir ja schon immer auf der Nerven gegangen. In C# 3.0 gibt es dafür jetzt einen einfachen Ersatz:

Auto-implemented properties make property-declaration more concise when no additional logic is required in the property accessors. When you declare a property as shown in the following example, the compiler creates a private, anonymous backing field can only be accessed through the property's get and set accessors.

class LightweightCustomer
{
    public double TotalPurchases { get; set; }
    public string Name { get; private set; } // read-only
    public int CustomerID { get; private set; } // read-only
}

Einen Rückschritt sehe ich dagegen in den Partial Methods:

A partial class or struct may contain a partial method. One part of the class contains the signature of the method. An optional implementation may be defined in the same part or another part. If the implementation is not supplied, then the method and all calls to the method are removed at compile time.

Was ein interessanter Schritt in Richtung Trennung von Header und Implementation hätte sein können wird so zu einer riesigen Fehlerquelle.

Das gibts auch jetzt schon:
http://msdn2.microsoft.com/de-de/library/hs24szh9(VS.90).aspx

Das Vista SDK der Beta 2 konnte bei mir nicht deinstalliert werden, weil 2008 ohne es nicht mehr funktionieren würde. Leider hatte ich 2008 zu dem Zeitpunkt schon lange von der Platte geputzt. Musst alle Einträge dazu manuell aus der Registry und von der Platte löschen. Danach hat auch die Installation der RTM funktioniert. Besonders schön ist auch, dass man jetzt mit C++ Express auch wieder native Anwendungen erstellen kann ohne sich die 400MB PSDK zu laden.

Versuch den Code doch einfach mal so wie floste ihn dir vorgegeben hat bevor du ihn veränderst. Und dein Array ist auch zu klein.

Da würdest du keinen großen Erfolg haben. In 99% der Threads kommt auch so ein ? vor. Dein Beispiel kannte ich schon, aber kennst du auch schon den ?? Operator?
PS:

Ein Postskriptum (v. lat. post „hinter, nach“ u. scribere „schreiben“) ist ein Anhang an einen Text. Deutsche Bezeichnungen sind Nachschrift, Nachsatz und die Abkürzung NS.. Es wird oft in Briefen oder ähnlichen Kommunikationsvarianten wie E-Mail oder Usenet verwendet.

Wenn es als Kennzeichnung eines Anhanges benutzt wird, schreibt man seine Bezeichnung nie aus. Es wird immer durch PS: abgekürzt. Andere Schreibweisen wie P.S.: oder PS.: werden zwar oft verwendet, sind jedoch falsch.

Bei weiteren Postskripta setzt man jeweils ein weiteres P hinzu:

* erstes Postskriptum: PS  
* zweites Postskriptum: PPS  
* drittes Postskriptum: PPPS  
* und so weiter

😉

X = Width/2 + ValueXWidth/2
Y = Height/2 + ValueYHeight/2

//€ So wie ichs gelesen hab bekommt er immer zwei Werte zwischen -1 und 1. Der Threadtitel macht mich aber doch etwas stutzig.

KVP ist readonly.

Sehr gut 🙂 Darum gings mir.

Aber der Fokus kommt nicht von allein in das Feld, sondern wird von einem kleinen JS auf die Suche rechts gesetzt.
Wenn man eine neue Antwort erstellt liegt der Fokus ja auch nicht auf der Suche, obwohl es das erste Eingabefeld ist 😉
Und mit Absicht den "schlechtere" Kasten auszuwählen finde ich schon sinnbefreit.

Hallo,

ich frage mich, wie die Indexierung hier im Board realisiert ist. Der Grund ist einfach: Ich wollte einen meiner Beiträge mit einem Keyword kennzeichnen, aber trotzdem finde ich ihn nicht in der Suche. Ich hab dann mal zum Testen herbivores "1000 Worte" probiert, aber auch das wurde nicht gefunden. Wird der Index nur alle paar Tage aktualisiert, oder werden bestimmte Wörter einfach nicht aufgenommen?

MfG

Ist es eigentlich Absicht, dass die Suche rechts oben den Fokus bekommt, wenn man links auf Suche klickt? Halte ich für ziemlich sinnbefreit. Wenn man schon extra links auf den Link klickt will man seine Suche vermutlich einschränken und da wäre ein Fokus im "internen" Suchfeld besser. Es ist zwar nur kein Klick, aber nerven tut's schon, wenn man lostippt und dann nochmal die Maus in die Hand nehmen muss.

Spontan würde ich das mit einem AutoResetEvent machen:

AutoResetEvent _are = new AutoResetEvent(false);
[...]
webBrowser1.Navigate(actAction._URI);
_are.WaitOne();
[...]
webBrowser1_DocumentCompleted:
_are.Set();

So heute ist Montag und hier ist die Lösung:

class Cent
{
    public int Count;
    public int CombinationsCount;
    public int Value;
    public bool[] CombinesWith = new bool[100];
}

struct Combination
{
    public int CentVal1;
    public int CentVal2;
}

Queue<string>[] originalPrices = new Queue<string>[100];
Cent[] cents = new Cent[100];
List<Combination> combinations = new List<Combination>();

for (int i = 0; i < 100; i++)
{
    cents[i] = new Cent();
    cents[i].Value = i;
    originalPrices[i] = new Queue<string>();
}

using (StreamReader sr = new StreamReader(args[0]))
{
    string line;
    while ((line = sr.ReadLine()) != null)
    {
        int centPart = int.Parse(line.Split('.')[1]);
        originalPrices[centPart].Enqueue(line);
        cents[centPart].Count++;
    }
}

for (int i = 0; i < cents.Length; i++)
{
    for (int j = i + 1; j < cents.Length; j++)
    {
        int centsSum = (i + j) % 100;
        if (centsSum == 11 || centsSum == 33 || centsSum == 55 || centsSum == 77 || centsSum == 99)
        {
            cents[i].CombinesWith[j] = true;
            cents[j].CombinesWith[i] = true;
            if (cents[i].Count > 0 && cents[j].Count > 0)
            {
                cents[i].CombinationsCount += cents[j].Count;
                cents[j].CombinationsCount += cents[i].Count;
            }
        }
    }
}

List<Cent> leftoverCents = new List<Cent>(cents);
while (true)
{
    leftoverCents.RemoveAll(
        delegate(Cent c)
        {
            return c.Count < 1 || c.CombinationsCount < 1;
        });
    if (leftoverCents.Count == 0)
        break;

    leftoverCents.Sort(
        delegate(Cent c1, Cent c2)
        {
            return c1.CombinationsCount.CompareTo(c2.CombinationsCount);
        });

    Cent first = leftoverCents[0];
    for (int i = 1; i < leftoverCents.Count; i++)
    {
        Cent second = leftoverCents[i];
        if (second.CombinesWith[first.Value])
        {
            Combination combi = new Combination();
            combi.CentVal1 = first.Value;
            combi.CentVal2 = second.Value;
            combinations.Add(combi);
            first.Count--;
            second.Count--;

            for (int j = 0; j < leftoverCents.Count; j++)
            {
                if (leftoverCents[j].CombinesWith[first.Value])
                    leftoverCents[j].CombinationsCount--;
                if (leftoverCents[j].CombinesWith[second.Value])
                    leftoverCents[j].CombinationsCount--;
            }
            break;
        }
    }
}

foreach (Combination combi in combinations)
{
    Console.WriteLine("({0} {1})",
        originalPrices[combi.CentVal1].Dequeue(),
        originalPrices[combi.CentVal2].Dequeue());
}

BradlUndBla

Hi!

Ich habe für eine Simulation Vektoren gebraucht und mir dafür zwei Klassen geschrieben. Einmal in 2D und einmal in 3D.
Ich werde hier mal nicht näher auf die Bezeichnungen eingehen. Wenn man sich mit Vektorrechnung auskennt sollte das nicht das Problem sein.
Nur soviel:

Vector2D Vektor3D.GetDrawView(double xRatio, double yRatio)
{
    return Vector2D.FromXY(x + z * xRatio, y + z * yRatio);
}
Vector2D Vektor3D.StdDrawView
{
    get { return Vector2D.FromXY(x + z * 0.5, y + z * 0.25); }
}
------
VektorND ^ VektorND = Kreuzprodukt
VektorND * VektorND = Skalarprodukt
------
VektorND.Along(VektorND) = Der Anteil des Vektors parallel zum 2. Vektors wiederum als Vektor
------
VektorND.Perpendicular(VektorND) = Der Anteil des Vektors senkrecht zum 2. Vektors wiederum als Vektor
------
VektorND.AngleX = Der Winkel zwischen X und Y Achse
VektorND.AngleZ = Der Winkel zwischen Z und Y Achse
Die Winkel sind mit dem Uhrzeigersinn ausgerichtet und beginnen an der X-Achse

Ich habe inzwischen, mit Hilfe, eine schnelle Lösung für dieses Problem gefunden.
Den Code gibts wenn die 1. Runde des Wettbewerb beendet ist (am Montag).