Zeile lesen... und ich verblöde schließlich

Tag Jungs!

Ich will was ganz einfaches, funktionieren wills aber null. Tutorials hab ich schon durchgelsen UND ich hab schonmal was ähnliches gebastelt das funktionierte. Dieses mal geht es nicht weil ichs nicht drauf hab.

Das Programm soll alle Zeilen in einer Datei lesen und alle in denen der string 'Zeile' vorkommt, soll ausgegeben werden.

Anbei ist der Code welchen ich schon gebastelt hab. Funktioniert so aber null. Da sind kompliziertere Sachen einfacher... fuchsteufelswild modus :

using System;
using System.Collections.Generic;
using System.Text;
using System.IO;

namespace GetWire
{
    class Program
    {
        static void Main(string[] args)
        {
            


            string input = "zeile";
            

            try
            {
                using (StreamReader outp = new StreamReader("c:\\file.txt"))
                {
                    String OUTP;
                    OUTP = outp.ReadLine();
                    foreach (int test in outp.ReadLine())
                    {
                        while (OUTP != input)
                        {
                            OUTP = outp.ReadLine();
                        }
                    }

                }
            }
            catch (FileNotFoundException exc)
            {
                Console.WriteLine("File " + exc.FileName + " could not be found.");
                Console.ReadKey(true);
                return;
            }
            Console.ReadKey(true);
        }
    }
}

Gruß, Linus

Hallo Linus,

lesen (ReadLine) musst du schon alle Zeilen. Du darfst aber nur die übernehmen, in denen "Zeile" vorkommt (IndexOf).

herbivore

Re!

Wieder ich. Habs abgeändert, zeigt aber nichts an... 😦 Warum?

using System;
using System.Collections.Generic;
using System.Text;
using System.IO;

namespace GetWire
{
    class Program
    {
        static void Main(string[] args)
        {
            Console.WriteLine("GetWire");


            string input = "zeile";
            string output = "";

            try
            {
                using (StreamReader outp = new StreamReader("c:\\file.txt"))
                {
                    String OUTP;
                    OUTP = outp.ReadLine();
                    while (OUTP != input)
                    {
                        OUTP = outp.ReadLine();                        
                    }
                    Console.WriteLine(OUTP);
                }
            }
            catch (FileNotFoundException exc)
            {
                Console.WriteLine("File " + exc.FileName + " could not be found. Please ensure the file is present and configured. Please refer to readme.txt for further help.");
                Console.WriteLine();
                Console.WriteLine("Press any key to Exit ...");
                Console.ReadKey(true);
                return;
            }
            Console.ReadKey(true);
        }
    }
}

Hallo Linus,

ist eigentlich wirklich ein Problem zum selber suchen. Bin ja gerne bereit mal einen Stubs wie oben zu geben, aber jetzt solltest du es durch selber nachdenken hinbekommen. Guck mal wo WriteLines stehen und wo nicht. Dann solltest du es sehen. Außerdem benutzt du noch kein IndexOf. Also, mach jetzt mal alleine. 🙂

herbivore

Re!

Das müsste doch auch ohne IndexOf gehen oder? Zumal kenn ich mich damit noch ganricht aus. Ich komm einfach nicht weiter und sitzt schon einige stunden an diesem simplen ding welches ich einfach nicht hin bekommen kann...

Im Moment liest mir das Programm eine Zeile ein und zwar diese welche 'Zeile 1' trägt. Mehr oder weniger darf aber auch nicht drin stehen da es sonst wieder nicht funktioniert... es verläuft sich dann irgendwie.

No idea anymore... hier der Code;

using System;
using System.Collections.Generic;
using System.Text;
using System.IO;

namespace GetWire
{
    class Program
    {
        static void Main(string[] args)
        {
            Console.WriteLine("GetWire");

            
            string input = "zeile 1";
            // string output = "";

            try
            {
                using (StreamReader outp = new StreamReader("c:\\file.txt"))
                {
                    String OUTP;
                    OUTP = outp.ReadLine();
                    while (OUTP != input)
                    {
                        OUTP = outp.ReadLine();
                    }
                    input = OUTP;   
                    Console.WriteLine(input);
                    
                }
                
            }
            catch (FileNotFoundException exc)
            {
                Console.WriteLine("File " + exc.FileName + " could not be found. Please ensure the file is present and configured. Please refer to readme.txt for further help.");
                Console.WriteLine();
                Console.WriteLine("Press any key to Exit ...");
                Console.ReadKey(true);
                return;
            }
            Console.ReadKey(true);
        }
    }
}

Irgendwie machst du es dir komplizierter als es ist.

Schau mal in die Doku, dort heißt es, dass ReadLine() die gelesene Zeile zurückgibt oder null, wenn der Reader am Ende der Datei ist. Mit IndexOf kannst du lleicht bestimmen, ob eine bestimmte Zeichenkette (die gelesene Zeile) eine andere Zeichenkette (z.B. "Zeile") enthält.

Du machst also eine Schleife, führst darin ReadLine aus. Wenn das Ergebnis null ist, bist du am Ende der Datei und musst die Schleife verlassen. Ansonsten schaust du nach ob IndexOf("Zeile") für die gelesene Zeile ≥ 0 ist. Dann enthält die Zeile das gesuchte Wort.

Grüße,
Andre

Hm, Danke Leute für eure Mühe. Ich gebs auf, ich kanns einfach nicht...

Bis die Tage

Hallo Linus,

Na komm, etwas mehr Durchhaltevermögen solltest du als Programmierer schon an den Tag legen. Das ist sicherlich nicht das letzte Problem, auf das du in deinem Leben treffen wirst. Jetzt zeig uns, dass sich unsere Mühen gelohnt haben und beiß dich durch!

Grüße,
Andre

Sorry, aber sowas kann ich irgendwie nicht nachvollziehen...

Mal abgesehen davon, dass da absolute minimal Basics dahinter stehen ist es mir unklar warum du gleich bei sowas ⚠ aufgibst!

Mit ReadLine liest du eine ganze Zeile ein - du vergleichst die gesamte Zeile mit deinem string "zeile"... sprich dein Programm macht sowas: if ("Zeile 1" == "zeile") - und da sollte es bei dir eigentlich klar werden. Du willst ja nicht wissen ob die Zeile genau diese Zeichenkette ist, sondern ob sie die Zeichenkette "zeile" enthält. Das kannst du wiederum mit den Funktionen von string machen --> entweder du benutzt string.IndexOf (gibt dir die Position einer Zeichenketter innerhalb einer anderen Zeichenkette wieder) oder noch einfach string.Contains - damit kriegst du einen bool wert zurück der dir deine gewünschte Information gibt.

Ehrlich gesagt, bin ich etwas schockiert.
Ich habe jetzt hier im Forum schon einige Fragen gelesen, die deutlich machen, dass der Poster keinen - Entschuldigung für den direkten Ausdruck - blassen Schimmer davon hat, was er eigentlich tun will, zusätzlich nicht in der Lage ist, eine Suchmaschine zu benutzen (sei es hier im Forum oder allgemein) und dann die gefundenen Informationen richtig umzusetzen und zu allem Überfluss auch noch meint, dass andere ihm die Arbeit (vor allem die Denkarbeit) abnehmen.
Oftmals wurde ich wieder etwas versöhnlich, weil ich dann etwas wie "seit einer Woche C#" o.ä. gelesen habe.
Dies entschuldigt viele Fragen, die mit etwas mehr Erfahrung einfach nicht mehr auftauchen (allerdings nicht persönliche Faulheit).

Um es auf den Punkt zu bringen:
Ich verstehe nicht, wie jemand, der sich am 19.05.2005 angemeldet hat und sich damit schon seit knapp 1,5 Jahren mit C# beschäftigt, solche Fragen stellen kann und dann auch sofort aufgibt, bloss weil ihm nicht gleich der Code vorgesetzt wird.

Das ist mir einfach unbegreiflich. Ich habe auch mal angefangen. Und hätte es damals solche Foren gegeben, ich hätte mich wahrscheinlich auch ziemlich blöde angestellt. Nur habe ich auch Bücher gelesen, ausprobiert und programmiert. Mir wäre es peinlich, solche Fragen zu stellen. Und ich bin spätestens beim Debuggen in der Lage, solche logischen Fehler zu finden.

Hallo,

Ich mache an dieser Stelle zu, da ich hoffe, dass die Botschaft angekommen ist und ich nicht davon ausgehe, dass in diesem Thread noch viel Fruchtbares entsteht.

Nagut, zeigen werd ich euch noch lange nichts, wahrscheinlich auch in ferner Zukunft nicht... zumindest im Berreich C#...

Im folgenden beziehe ich mich auf Zeile lesen... und ich verblöde schließlich

Entgegen jeglicher Erwartungen trug die Konversation mit 'herbivore','VizOne' und 'DCoder' doch Früchte und jeder einzelne von euch hat mir weiter geholfen. An dieser Stelle (an der anderen Stelle gehts ja nemmer 😉 ), Vielen Dank!!!

Heute morgen frisch ans Werk, angreifende Aussagen eines 'Borg' hart an mir abprallen lassen (sollte er mich nicht eher assimilieren und ins Kollektiv einbinden?) und mutig an den Code. Mit den Tips vom Vortag über ein paar Stunden weg viel probiert, gebastelt und erreicht. Das sollte wiederlegen, dass ich nur darauf warte fertigen Code vorgesetzt zu bekommen, zumal, ich wiederhole mich, ich schon ein paar andere Programme geschrieben habe. Kurz und gut, ich habe das Programm funktionsfähig zur Hand, mit nur noch einem Bug.

Reminder:

Das Programm soll in einer Textdatei alle Zeilen nach einem String durchsuchen und die Zeilen, welche diesen String enthalten, ausgeben.

Der Bug:

Er hört nach der 107. Zeile auf.

Ich denke, ihr hättet das alles anders gelöst, ich bin aber froh, dass ich es mit meinem Wissen soweit gebracht habe. Hier der Code:

namespace GetWire
{
    class Program
    {
        static void Main(string[] args)
        {
            Start:
            Console.Clear();
            Console.WriteLine("Enter your search criteria (case sensitive):");
            Console.WriteLine();
            string input = Console.ReadLine();
            Console.WriteLine();
            Console.WriteLine("Searching for '" + input + "' ...");
            Console.WriteLine();
            try
            {
                using (StreamReader outp = new StreamReader("c:\\file.txt"), )
                {
                    int a = 0;
                    foreach (int i in outp.ReadLine())
                    {
                        String OUTP;
                        OUTP = outp.ReadLine();
                        try
                        {
                            if (OUTP.Contains(input))
                            {
                                Console.WriteLine(OUTP);
                                Console.WriteLine();
                                Console.WriteLine(i);
                                a++;
                                throw new NullReferenceException();
                            }
                        }
                        catch (NullReferenceException) {}
                        finally { }
                    }
                    Console.WriteLine();
                    Console.WriteLine(a++ + " Results");
                }
            }
            catch (FileNotFoundException exc)
            {
                Console.WriteLine("Database not found!!!");
                Console.WriteLine();
                Console.WriteLine("Press any key to exit ...");
                Console.ReadKey(true);
                return;
            }
            Console.WriteLine();
            Console.WriteLine("Done! Any key for new search, strg + c to exit ...");
            Console.ReadKey(true);
            goto Start;
        }
    }
}

Ich kann hier leider nichts sehen warum er nach Zeile 107 die Schleife beendet.

Seht ihr was?

Gruß
The Rising C# Star, Linus

Ja, offenbar hast Du wirklich mehr gedacht als gestern.
Aber einiges ist mir noch nicht klar:

1. Du verwendest zweimal kurz hintereinander outp.ReadLine()
   Beim ersten mal erwartest Du, dass es ein int zurückgibt und beim zweiten mal einen String. Letzteres ist ja auch richtig, aber die Sache mit dem int verstehe ich nicht.
   Stehen in der Datei immer abwechselnd Zahlen und Strings? Ich würde erwarten, dass der Compiler an dieser Stelle aber meckert, weil er ja einen String erwartet.

2. Warum wirfst Du mitten im völlig richtigen Programmablauf einfach mal so ne NullReferenceException? Das ist nicht nur verwirrend und unperformant (ja, ich weiß, dass Exceptions nicht besonders unperformant sind, aber bestimmt unperformanter als sie nicht zu werfen) sondern auch gefährlich, weill ja andere NullReferenceExceptions ebenfalls von Deinem catch(NullReferenceException) abgefangen würden, was aber mitunter gar nicht gewollt ist.

3. Console.WriteLine(a++ + " Results"); ist zwar sehr kurz, aber weißt Du auch in welcher Reihenfolge die Anweisungen und Operatoren ausgeführt werden?

4. goto ist eventuell in diesem Beispiel sogar lesbarer als ein while(true) drumrum zu machen, aber grundsätzlich solltest Du immer Bauchschmerzen bekommen, wenn Du goto verwendest.

Na dann, viel Erfolg noch mit Deinem neugewonnen Durchhaltevermögen!

Hallo,

Schön, dass du weiter dran bleibst!

Diese Zeile:

foreach (int i in outp.ReadLine())

Macht nicht viel sinnvolles in deinem Zusammenhang. Es führt die Schleife für jedes Zeichen in der ersten Zeile einmal aus. Das ist nicht das, was du willst! Du willst ReadLine so oft lesen, bis es null zurückgibt.

Grüße,
Andre

Hallo,
Dein Problem liegt in dieser Schleife:

                    foreach (int i in outp.ReadLine())
                    {
                        String OUTP;
                        OUTP = outp.ReadLine();
                        try
                        {
                            if (OUTP.Contains(input))
                            {
                                Console.WriteLine(OUTP);
                                Console.WriteLine();
                                Console.WriteLine(i);
                                a++;
                                throw new NullReferenceException();
                            }
                        }
                        catch (NullReferenceException) {}
                        finally { }
                    }
                    Console.WriteLine();
                    Console.WriteLine(a++ + " Results");
                }

Die foreach-Schleife kannst Du Dir komplett sparen, die ist an dieser stelle auch unsinnig. --> Was bezweckst Du damit??
Du liest nämlich nur genau die Anzahl an Zeilen, die die erste Zeile an Zeichen hat. Du solltest aber so lange lesen, wie Du aus der Datei noch neue Zeilen bekommst -> da bietet sich eine while-Schleife an.

Lord Hesia

Zu 1: Das mit dem int ausgeben ignorieren, das wollte ich vor dem Posting noch heraus nehmen, habs vergessen....

Zu 2: Die exception werf ich, weil er es so von mir will. Wenn ich es nicht mache, meckert er...

Zu 3: Ne, aber es scheint zu funktionieren...

Zu 4: Das hab ich schon öfert gehört. Ich werde die Sache mit dem Goto auch weg machen. Aber im Moment habe ich noch das Problem mit den 107 Zeilen...

Linus

THX VizOne, THX MarsStein...

*Ganz große Birne an geht und die Umgebung erleuchtet*

1. Ok, wenn Du statt der ersten Zeilen vier Zeilen des foreach schreibst

while(String OUTP = outp.ReadLine()) {

so wie das ja MarsStein und VizOne gesagt haben, dann erübrigt sich ja auch das mit dem int.

2. Was ist denn die genaue Meldung? Falls da nur steht, dass eine NullREferenceEx erwartet wird, dann entferne mal das umgebende try catch. Dasi ts die bessere Lösung 😉

3. Ja mag sein. Aber wenn Du aus der Anweisung zwei machst, dann funktioniert es auch und Du weißt auch was sie tut.

string line;
while (line = outp.ReadLine())
{
    if (line != null && line.Contains(input))
        Console.WriteLine(line);
}

Nach dem verlängerten Wochenende...

Guten Tag Leute!

Vielen Dank für euren Input... Werd mich gleich wieder ran machen...

Linus

Original von Burgpflanze

string line;  
while (line = outp.ReadLine())  
{  
    if (line != null && line.Contains(input))  
        Console.WriteLine(line);  
}  

sorry aber

while (line = outp.ReadLine())

dürfte doch garnicht funktionieren, oder?
also von daher ganz schnell vergessen

@linus
am besten du überlegst dir nochmal die genaue vorgehensweise für dein problem, denn du hast da einige fehler drin

schau mal, zunächst mal mußt du ja jede zeile der datei einlesen
dafür gibt es ReadLine, das gibt einen string zurück oder null wenn am ende
daraus läßt sich doch wunderschön eine schleife bauen oder nicht?

wenn du einen zähler für die zeile brauchst, nimmst du dir einfach eine int-variable die du vor der schleife auf 0 setzt, und in der schleife immer um 1 hochzählst.
so kannst du bei der ausgabe auch die zeilennr. angeben

zum prüfen ob ein streing im andere nenthalten ist bietet sich Contains an, da es ein boolean zurück gibt kann man dsa serh shcön in einer if-bedingung verwenden

glaub der rest ist nur noch formsache oder? 😉

Original von sheitman
sorry aber

while (line = outp.ReadLine())  

dürfte doch garnicht funktionieren, oder?

Kannst Du Deine Annahme noch begründen? Wüsste nicht, warum das nicht gehen sollte.

Hallo Lord Hessia,

weil in einem while ein boolscher Ausdruck stehen muss, es ist aber ein String-Ausdruck.

herbivore

Würde null nicht auch als false ausgewertet?

Hallo Lord Hessia,

das will ich nicht hoffen. 🙂

herbivore

Würde null nicht auch als false ausgewertet?

das will ich nicht hoffen.

ich hoffe das allerdings auch nicht.
vermute mal in alten c zeiten würde das bestimmt funktionieren.

aber c# ist da ja (zum glück) ein bisschen anders.

*tilt*

vielleicht sollte ich nicht alles lesen...

Original von Linus
*tilt*

vielleicht sollte ich nicht alles lesen...

sorry, jetzt wir dich wohl ein bisschen zu viel verwirrt, oder wie ist tilt zu verstehen.....

Original von nils

Original von Linus
*tilt*

vielleicht sollte ich nicht alles lesen...

sorry, jetzt wir dich wohl ein bisschen zu viel verwirrt, oder wie ist tilt zu verstehen.....

... arg verwirrt. OUHA, ich hab da eben ewig an der Sache herum gemacht über die nun heraus kam, dass sie nicht funktioniert...

hast du es denn lösen können ??

Nein, bin noch dran... es wird. Wenns final ist, poste ich mein Ergebnis... wennnnns final ist

Original von Linus
... arg verwirrt. OUHA, ich hab da eben ewig an der Sache herum gemacht über die nun heraus kam, dass sie nicht funktioniert...

Nun ja, so groß sind die Unterschiede zwischen funktioniert und funktioniert nicht in diesem Fall ja nicht. Worüber wir gearde diskutiert haben:

while (line = outp.ReadLine()) // Funktioniert nicht
...
while ((line = outp.ReadLine()) != null) // Funktioniert

So weit jedenfalls die Aussagen von sheitman und herbivore.
Und ich war fest davon ausgegangen, dass false == null (== 0), aber das lag wohl daran, dass ich in letzter Zeit zu viel PHP gemacht habe. Es gibt halt einfach "böse" Sprachen, womit man sich nur selber versaut.

Lord Hessia,

habs nun so gemacht:

while (outp.ReadLine() != null)

Ich bin nah dran... Nun kommt er mir wieder mit ner affigen NullReferenceException in meiner IF-Anweisung... Ich versuchs weiter!!!

Gruß, Linus

Hallo Linus

siehe [FAQ] NullReferenceException: Der Objektverweis wurde nicht auf eine Objektinstanz festgelegt

herbivore

Original von Linus
Lord Hessia,

habs nun so gemacht:

while (outp.ReadLine() != null)  

Das Ergebnis von ReadLine() verschwindet hier ins Nirvana. Du möchtest auf jeden Fall das Ergebnis behalten. Kleiner Tipp, wenn du es unbedingt in einer Zeile lösen willst. Du kannst einer Variable etwas zuweisen und danach noch schauen, ob das null war. Allgemein:

 while( (variable = wert) != null) {}

Musst das jetzt nur noch auf dein Problem ummünzen 😉

Grüße,
Andre

Musst das jetzt nur noch auf dein Problem ummünzen 😉

siehe: Zeile lesen... und ich verblöde schließlich 😉

Unser Lehrer hat immer gesagt, 80% aller Antworten stehen bereits an der Tafel. In diesem Fall ist es nicht die Tafel sondern ein früherer Beitrag 😁

Re Leute!

Hier mein vorerst letztes Ergebnis.

                using (StreamReader outp = new StreamReader("c:\\file.txt"))
                {
                    int a = 0;
                    string OUTP = string.Empty;
                    do
                    {
                        OUTP = outp.ReadLine();
                        if (OUTP != null)
                        {
                            if (OUTP.Contains(input) &! OUTP.Contains("textbaustein"))
                            {
                                Console.WriteLine(OUTP);
                                Console.WriteLine();
                                a++;
                            }
                        }
                    }
                    while (OUTP != null);
                    Console.WriteLine(a + " Results");
                }

Ich hab noch mit eingebaut, dass er alle Zeilen welche den String 'textbaustein' enthalten auslassen soll.

Kann man bestimmt noch anders machen. Aber es funktioniert endlich...

Gruß, Linus

ps.: dabei fällt mir auf, dass man die beiden if noch zusammen basteln könnte 🙂

Warum du jetzt aus der While-Schleife eine Do-While-Schleife gemacht hast erschließt sich mir nicht ganz. Diese sollte man nur einsetzen, wenn etwas auf jeden Fall einmal durchlaufen werden soll. Mit der vorher eingesetzten Schleife (kombinierte Zuweisung und Abbruchbedingung) hattest du eine If-Abfrage weniger.

Außerdem solltest du bei deiner "Contains"-If-Abfrage kein bitweises Und benutzen! & -> &&

Original von Linus
ps.: dabei fällt mir auf, dass man die beiden if noch zusammen basteln könnte 🙂

Oder es ganz weglassen, wenn Du while statt do while verwendest, so wie es in meinem Post von 11:17 steht...

Mich wundert, dass das hier funktionieren soll:

if (OUTP.Contains(input) &! OUTP.Contains("textbaustein"))

& steht für ein binäres UND. Das logische UND, das Du meinst, wird durch && beschrieben.
Außerdem solltest Du Dir angewöhnen, das ! zur Negation immer direkt vor den zu negierenden Ausdruck zu schreiben, also

!OUTP.Contains("textbaustein")

Aktuell sieht es so aus, als ob das &! zusammengehörte.

P.S.: Man kann jetzt wieder lange drüber diskutieren, warum das & evtl. doch funktionert, obwohl es nicht das ist, was Du willst, aber das haben wir ja bereits an anderer Stelle zu einem anderen Thema getan und das hat Dir ja eher weniger als mehr geholfen, deshalb wollten wir es dieses Mal evtl. unterlassen 🙂

Tag Leute!

Eingehend getestet, & !OUTP... funktioniert hervorragend.

Gruß Linus

& bei boolean macht das gleiche wie &&, der unterschied ist, das bei && keine weiteren werte ausgewertet werden sobald das ergebns fest steht, d.h. bei && sobald ein wert false hat wird nicht mehr verglichen
bei & wird stattdessen auch der 2. wert noch ausgewertet
wozu brauch man das?
z.b. wenn man bewußt mit seiteneffekten arbeiten möchte 🙂

das gleiche gilt für | bzw. ||

Ok, dann kann ich doch nicht an mich halten. Natürlich funktioniert es, aber es ist nicht das, was Du willst. Es ist zwar nett, wenn die richtigen Ergebnisse rauskommen, aber auch der Weg zum Ergebnis sollte richtig sein. Kein Mensch fährt über München wenn er von Frankfurt nach Basel will, obwohl er auch ankäme und das Ergebnis das gleiche wäre.

if (OUTP.Contains(input) &! OUTP.Contains("textbaustein"))

Bei diesem Ausdruck geschieht folgendes:

• OUTP.Contains(input) => wird ausgewertet zu true oder false, in der Folge als boolean_a bezeichnet
• OUTP.Contains("textbaustein") => wird ausgewertet zu true oder false, in der Folge als boolean_b bezeichnet
• ! OUTP.Contains("textbaustein") => boolean_b wird negiert, in der Folge als boolean_bneg beteichnet
• OUTP.Contains(input) &! OUTP.Contains("textbaustein") => boolean_a und boolean_bneg werden binär UND-verknüpft. D.h. true wird als 0000 0000 0000 0001 und false als 0000 0000 0000 0000 angesehen. Die UND-Verknüpfung sorgt dafür, dass Stellen, die sowohl bei boolean_a als auch bei boolean_bneg 1 sind auch im Ergebnis 1 sein, alles andere wird zu 0.
  Das ergibt, dass nur aus true & true (also 0000 0000 0000 0001 und 0000 0000 0000 0001) wieder true wird. Im Prinzip genau das, was Du willst.

In diesem speziellen Fall funktioniert es also, aber schon bei folgendem Ausdruck würde es gewaltig auf die Schnauze fallen:

if (OUTP != null &! OUTP.Contains("textbaustein"))

Ein Unterschied zwischen binären (&) und logischen (&&) Operatoren ist nämlich, dass logische nur immer so weit ausgewertet werden, wie unbedingt nötig. Im obigen Fall würde das Ergebnis also bereits zu false ausgewertet, wenn OUTP null ist. Dadurch würde der zweite Teil (OUTP.Contains.. ) nicht mehr angefasst, was andernfalls auch ne Null-Pointer-Exception erzeugen würde.

Ich nehme mal an, dass Du nur für Dich selber programmierst, aber trotzdem solltest Du auch noch bedenken, dass Leute, die Deinen Code lesen ungefähr folgende Gedankengänge durchmachen müssen, um es zu verstehen, während bei Verwendung eines && alles klar wäre 🙂

Und hier noch ein netter Text zu Datentypen in C#: http://de.wikibooks.org/wiki/Programmierkurs_C-Sharp:_Datentypen

Ok, sheitman hat das ganze in der halben Zeit und mit der Hälfte des Textes auch beschreiben können...

Lord Hessia, trotzdem THX für die detailierte Analyse... 🙂

Ich hab dashier verbaut:

if (OUTP != null && OUTP.Contains(input) &! OUTP.Contains("**GetWire"))

Gruß, Linus

@Lord Hessia:
Deine Erklärung stimmt so nicht. Denn der &-Operator auf bool angewandt führt keinen binären Vergleich durch, sondern einen logischen wie der &&-Operator. Nur mit dem Unterschied, dass beide Seiten immer ausgewertet werden.

The unary & operator returns the address of its operand (requires unsafe context).

Binary & operators are predefined for the integral types and bool. For integral types, & computes the logical bitwise AND of its operands. For bool operands, & computes the logical AND of its operands; that is, the result is true if and only if both its operands are true.

The & operator evaluates both operators regardless of the first one's value.

Original von Linus
Lord Hessia, trotzdem THX für die detailierte Analyse... 🙂

Ich hab dashier verbaut:

if (OUTP != null && OUTP.Contains(input) &! OUTP.Contains("**GetWire"))  

Gruß, Linus

besser wäre

if (OUTP != null && OUTP.Contains(input) && !OUTP.Contains("**GetWire"))

dann herst du nun endlich mal das ! vor dem methodenaufruf, wie sic hdsa auc hgehört, udn du machst wirklich nur die notwendigsten vergleiche...

Original von marsgk
Denn der &-Operator auf bool angewandt führt keinen binären Vergleich durch, sondern einen logischen wie der &&-Operator. Nur mit dem Unterschied, dass beide Seiten immer ausgewertet werden.

Hallo marsgk,

vielen Dank für die Information. Das wusste ich nicht. Ist das eine Besonderheit von C#? Ich habe das bei C++ oder Java nämlich noch nie gehört...

Es sei denn er hat nach wie vor das

if (OUTP != null)

bereits vor der Klammer stehen... 😉