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

Zespire

Lieutenant
Registriert
März 2007
Beiträge
857
Folgendes Beispiel.

Code:
	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.
 
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
 
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?
 
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

Code:
	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 ?
 
Zuletzt bearbeitet:
Zespire schrieb:
Edit: Aber das würde es für den Compiler noch schwerer machen vorhersagen zu treffen oder ?

Du kannst die if-Verzweigung eigentlich weglassen:
Code:
private bool Vergleiche(KlasseContainer newContainer,EnumContainerTyp typ)
{
	return (typ == EnumContainerTyp.Rot && newContainer.Name.CompareTo(this.Name) > 0)
		|| (typ == EnumContainerTyp.Blau && newContainer.Gewicht > this.Gewicht)
}
 
Zuletzt bearbeitet von einem Moderator:
Ist doch eher eine frage was man leserlicher findet oder ?

Und für etwas mehr Verständnis etwas vom eigentlichen Code...
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();
	}
 
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. :D
 
Wen man genug zeit für ein Bubblesort hat ist doch alles gut oder ? :p
 
Zuletzt bearbeitet von einem Moderator:
Zurück
Oben