C# Optimiert der C# Compiler meinen nicht optimalen Code ?

[Zespire]

Folgendes Beispiel.

	private void Insert(KlasseContainer newContainer,EnumContainerTyp typ)
	{
		List<Container> containerListe;

		for(int i = 0; i < containerListe.Count; i ++)
		{
			if(typ == EnumContainerTyp.Rot && newContainer.Name.CompareTo(containerListe[i].Name) > 0 ||typ == EnumContainerTyp.Blau && newContainer.Gewicht > containerListe[i].Gewicht)
			{
				return;
			}
		}
	}

Jetzt wird sich der typ in der Schleife nicht mehr ändern also muss man ja den typ nicht bei jeder if Abfrage prüfen womit wir zu meiner Frage kommen ob der Compiler das optimiert...

Genau so frage ich mich wie ich den Code am besten anlege wen ich Zb 50 verschiedene Container habe
der Gedanke von 50 if Statements die nahe zu den selben Code ausführen gefällt mir nicht und genau so wenig ein riesen if statment mit 50 or Operatoren.

 

[rg88]

ohne jetzt wirklich zu kapieren was du vorhast, ist so eine Frage zwecks Optimeirungen immer schwierig.
Im Grunde verlässt man sich nicht auf den Compiler, sondern programmiert selbst einfach sauber und effektiv. Der Compiler ist als Bonus zu sehen, nicht als Ersatz.

Mal ganz primitiv: Besser als eine if-Anweisung ist bei so einer Anzahl zwecks Übersichtlichkeit ein switch case Konstrukt. Aber ob das für deine Sache das richtige ist, weiß man ohne konkrete Angaben nicht

 

[Holt]

Wie soll man denn sinnvollerweise eine if Abfrage durch ein switch case Konstrukt ersetzen, zumal wenn beide der Bedingungen dort zur Ausführung des gleichen Codes führen sollen?

 

[Zespire]

Hab ein Inventar jetzt kann man nach Preis, Name, Größe und so weiter sortieren die einzelnen Werte sind in der Klasse Container Jetzt sortiert mir eine Funktion nach Namen und eine nach Preisen.

Somit habe ich zwei Funktionen die im Prinzip Text und Zahlen sortieren können aber trotzdem muss ich extrem viel Code wiederholen da ich jedes mal festlegen muss welchen wert ich vom Container nehme also if(container.wertA > container.wertB)...

Beim schreiben kam mir eine die Idee ich könnte dem Container eine Funktion hinzufügen die als Argumente einen Container und ein Enum nimmt und den Vergleich dann selber durchführt...

In etwa so

	private void Insert(KlasseContainer newContainer,EnumContainerTyp typ)
	{
		List<Container> containerListe;

		for(int i = 0; i < containerListe.Count; i ++)
		{
			if(newContainer.Vergleiche(containerListe[i],typ))
			{
				return;
			}
		}
	}

	private bool Vergleiche(KlasseContainer newContainer,EnumContainerTyp typ)
	{
		if(typ == EnumContainerTyp.Rot && newContainer.Name.CompareTo(this.Name) > 0)
			return true;
		if(typ == EnumContainerTyp.Blau && newContainer.Gewicht > this.Gewicht)
			return true;

		return false;
	}

Edit: Aber das würde es für den Compiler noch schwerer machen vorhersagen zu treffen oder ?

 

[DerWeisseFisch]

Edit: Aber das würde es für den Compiler noch schwerer machen vorhersagen zu treffen oder ?

Du kannst die if-Verzweigung eigentlich weglassen:

private bool Vergleiche(KlasseContainer newContainer,EnumContainerTyp typ)
{
	return (typ == EnumContainerTyp.Rot && newContainer.Name.CompareTo(this.Name) > 0)
		|| (typ == EnumContainerTyp.Blau && newContainer.Gewicht > this.Gewicht)
}

 

[Zespire]

Ist doch eher eine frage was man leserlicher findet oder ?

Und für etwas mehr Verständnis etwas vom eigentlichen Code...

	// Sort by Name ----------------------------------------------------------------------------
	private void NameButtonTask()//Wird ausgeführt wen der User den "sort by name button" drückt
	{
		for(int i = 0; i < sortingLayers.Length; i++)
			if(sortingLayers[i] == SortingType.name)
			{
				if(sortedUpwards[i])
				{
					iventoryList.Reverse();
					UpdateIndexes();
					ResetParents();
					return;
				}
				else
				{
					sortedUpwards[i] = true;
					break;
				}
			}
		
		SortByName();
	}

	private void InsertButtonByName(TestInventoryButton button)//Der plan ist hier den SortingType zu übergeben zb (TestInventoryButton button,SortingType type)
	{
		for(int i = 0; i < sortingLayers.Length; i++)
			if(sortingLayers[i] == SortingType.name)// wäre dann if(sortingLayers[i] == type)
				sortedUpwards[i] = false;
		
		if(iventoryList.Count == 0)
		{
			iventoryList.Add(button);
			button.InventoryIndex = 0;
			return;
		}	

		for(int i = 0; i < iventoryList.Count; i ++)
			if(button.Item.Name.CompareTo(iventoryList[i].Item.Name) > 0)//und hier wäre es if(button.CompareSortingValue(iventoryList[i],type) 
			{
				iventoryList.Insert(i,button);
				button.InventoryIndex = i;
				return;
			}

		iventoryList.Add(button);
		button.InventoryIndex = iventoryList.Count;
	}

	public void SortByName()//bubblesort hier das selbe (SortingType type)
	{
		for(int i = 0; i < iventoryList.Count; i ++)
			for(int n = 0; n < iventoryList.Count - 1; n ++)
				if(iventoryList[n].Item.Name.CompareTo(iventoryList[n+1].Item.Name) > 0)// und wieder if(button.CompareSortingValue(iventoryList[i],type) 
					SwapInventoryItems(n,n+1);
		UpdateIndexes();
		ResetParents();
	}

 

[Shio]

Solang der Code nicht zeitkritisch ist, so einfach wie möglich halten. Alles Andere führt nur zu Kopfschmerzen. ^^
So einfacher der Code um so einfacher ist es für den Compiler auch die nötigen Muster zu erkennen um den Code sinnvoll zu optimieren.
IMHO ist es auch besser erst den Code in seiner einfachsten Form fertigzustellen, bevor dann per Hand daran "optimiert" wird.

 

[Zespire]

Wen man genug zeit für ein Bubblesort hat ist doch alles gut oder ?

 

[E-tech]

Ich hab nur kurz zwischen Tür und Angel drauf geguckt, aber aus Java sind mir die Sortiermethoden der Collections bekannt. Unter C# müsste das hier passen:
https://msdn.microsoft.com/de-de/library/w56d4y5z(v=vs.110).aspx

Für Java: https://docs.oracle.com/javase/7/do...ml#sort(java.util.List, java.util.Comparator)

Darüber sollte man sich bezüglich der Lesbarkeit eher Gedanken machen. Es gibt da draußen Leute, die eher wissen, wann welcher Sortieralgorithmus ideal ist .

 

[Bagbag]

Beim Code in deinem Eingangspost wird der Compiler höchstwahrscheinlich nichts im Sinne von "erst prüfen, dann schleife" optimieren. Dafür kommt hier "Branch Prediction" der CPU ins spiel, die vorrauschaut, dass die Bedingung immer zutrifft.

Siehe hierzu auch die äußerst intressenten Stack Overflow Antworten zu dieser Frage: https://stackoverflow.com/questions/11227809/why-is-it-faster-to-process-a-sorted-array-than-an-unsorted-array