C#: Manipulierte Eingangsparameter kennzeichnen

[Horst S. (Gast)]

Bei folgender Problemstellung bete ich immer, dass mein Quellcode so gut 
läuft, dass ich ihn nie mehr anschauen muss (sonst habe ich sowieso 
wieder vergessen, was da passiert):
Als Array vorliegende Daten müssen durch unterschiedliche Funktionen 
klassifiziert werden. Konkret geht es um einen Rundumsensor, dessen 
einzelne Punkte in Linien, Punktwolken und Restpunkte zerlegt werden. Um 
kenntlich zu machen, dass Punkte einer Linie nicht mehr für Punktwolken 
oder Restpunkte zur Verfügung stehen, werden die Werte in der 
entsprechenden Klassifizierung auf null gesetzt.
Irgendwie aber blöde zu lesen. Weder "ref" noch "out" scheinen das 
richtige Schlüsselchen zu sein, um meinem Kollegen (oder mir in einem 
halben Jahr) zu zeigen, dass das Eingabefeld über die Unterroutinen von 
ProcessInput manipuliert wird. Bleibt mir da wirklich nur die 
Kommentierung?

        /// <summary>
        /// ...
        /// </summary>
        /// <remarks>"samples" parameter will be destroyed after call</remarks> 
        public List<IPart> ProcessInput(ScanPoint[] samples)
        {
            List<IPart> rval = new List<IPart>(); 
            rval.AddRange ( GetLines(samples));
            rval.AddRange ( GetPointClouds(samples));
            rval.AddRange ( GetPoints(samples));
            return rval;
        }



        /// <summary>
        /// ...
        /// </summary>
        /// <param name="samples"></param>
        /// <returns></returns>
        /// <remarks>used points will be wiped out from samples</remarks> 
        List<IPart> GetLines(ScanPoint[] samples)
        {
            List<IPart> rval = new List<IPart>();
            //Identify lines ...

            //dummy: wipe out used input points
            for (int i = 0; i < 42; i++)
            {
                samples[i] = null;
            }
            return rval;
        
        }

        /// <remarks>used points will be wiped out from samples</remarks> 
        List<IPart> GetPointClouds(ScanPoint[] samples)
        {
            List<IPart> rval = new List<IPart>();
            //Identify PointClouds ...

            //dummy: wipe out used input points
            for (int i = 42; i <= 84; i++)
            {
                samples[i] = null;
            }
            return rval;

        }

        List<IPart> GetPoints(ScanPoint[] samples)
        {
            foreach (ScanPoint ptIn in samples)
            {
                if (ptIn != null)
                {    // Ahh, its a point, so add it to rval;
                }
            }


        }

Merke: Es geht nicht darum, das Eingangsfeld vor der Zerstörung (durch 
kopieren) zu retten, sondern einen Reminder zu setzen, dass das 
Eingangsfeld zerstört wird.

Oder baut Ihr so etwas erst gar nicht?

Oder bin ich mittlerweile zu empfindlich?

[Peter II (Gast)]

   List<IPart> GetPointClouds(ScanPoint[] samples)
        {
            List<IPart> rval = new List<IPart>();
            //Identify PointClouds ...

            //dummy: wipe out used input points
            for (int i = 42; i <= 84; i++)
            {
                samples[i] = null;
            }
            return rval;

        }

das macht doch irgendwie keinen sinn. eine neue Liste zu erzeugen wo 
alle werte null sind.

Warum nicht einfach jeden Punkt aus der Liste löschen, wenn er 
verarbeitet ist. Dann musst du auch nicht auf null prüfen?

List<IPart> x = new List<IPart>();

// Punkte hinzufügen
x.Add(...);

// Funktion 1
x.Del( )

// Funktion 2
x.Del( )

dafür braucht man auch kein ref oder out, weil komplex Objekte immer als 
Referenz übergeben werden

[Horst S. (Gast)]

Unter Berücksichtigung, dass...
- samples an alle Unterfunktionen als Eingangsparameter weitergegeben 
wird
- IPart ein Interface für die zurückgegebenen Typen Linie Punktwolke und 
Restpunkte ist.
- das zurückgegebene List<IPart> der Unterfunktionen also eine Sammlung 
der jeweils klassifizierten Objekte zurückgibt
- In jeder Unterfunktion die von den erstellten Objekten verwendeten 
ScanPoints auf null gesetzt werden müssen (Ein ScanPoint kann nur 
ENTWEDER Bestandteil einer Linie ODER einer Punktwolke ODER ein 
verbleibender Einzelpunkt sein), damit sie in der folgenden Funktion 
nicht mehr verwendet werden.

...muss ich jetzt erst einmal fragen, was Du damit meinst (sorry).

[Horst S. (Gast)]

Vielleicht muss ich mal meine Frage umformulieren:

Welche Schweincheleien lasst Ihr in Euren Schnittstellen selber zu, 
damit Euer Code einerseits performt und andererseits Euch morgen noch 
schmeckt?

Ich sag mal, mit oben gezeigten zurücksetzen der ScanPoints auf null 
verstoße ich zumindest gegen das Paradigma, dass ich nicht weiß, wer 
mich aufruft und ob der Aufrufer den Eingangsparameter noch für etwas 
anderes braucht.

Kopieren ist allerdings auch blöd, wenn die Eingangswerte nirgendwo 
anders verwendet werden.

Hmm, vielleicht könnte ich eine Überladung einbauen:

public List<IPart> ProcessInput(ScanPoint[] samples, bool noDestroy)
{
    if (noDestroy)
        return ProcessInput((LineFinderInputPoint[]) samples.Clone());
    else
        return ProcessInput(samples);

}

manchmal findet man ja schon den Sinn der Sache, wenn man in der 
Schnittstelle sieht, dass es Alternativen gibt.

[Tom (Gast)]

Horst S. schrieb:
> Oder bin ich mittlerweile zu empfindlich?

Nein. Eine Funktion, die ganz unschuldig GetPoints heißt und dann ihre 
Eingabe zerstört, geht gar nicht. ExtractPointsAndWipeUsedSamples() oder 
so wäre OK.