# Codeabschnitte zusammenfassen



## HakBak (3. Jul 2008)

Hi, 
vielleicht stehts auch schon irgendwo und ich war zu doof zum suchen/finden, aber gibt es in Java sowas ähnliches wie @region in C#, mit dem man Code zu Blöcken zusammenfassen kann, damit, wenn mal ne Methode etwas ausladender wird, alles schön übersichtliche bleibt?

Dankeschön.


----------



## SlaterB (3. Jul 2008)

{



}


----------



## diggaa1984 (3. Jul 2008)

glaub er meint sowas wie "folding" ??


----------



## Gast2 (3. Jul 2008)

Moin,



			
				diggaa1984 hat gesagt.:
			
		

> glaub er meint sowas wie "folding" ??



ja ... mein er ... ist sehr Praktisch, da man/ich da zusätzlich noch Methoden sortieren kann und gleichzeitig ausblenden

gibt es mehr oder weniger ... wohl muss man sich aber wohl selber Programmieren

hand, mogel


----------



## Saxony (3. Jul 2008)

Hiho,

Folding hätte dann aber nichts mit dem Soruce an sich zu tun, sondern ist eine IDE Einstellungssache.

Wenn er aber auf Verwendung von @region hinweist, sieht es für mich so aus, als ob das in den Source müsste!?!

Übrigens #region - weil wegen Präprozessordirektive! 


```
#region MyClass definition
public class MyClass 
{
    static void Main() 
    {
    }
}
#endregion
```

Funzt aber nur:



			
				MSDN hat gesagt.:
			
		

> Mit #region kann ein Codeblock angegeben werden, der erweitert oder reduziert werden kann, wenn das Gliederungsfeature des Code-Editors von Visual Studio verwendet wird.



Das gleiche gibt es zum Beispiel für Eclipse und nennt sich folding! Hier kann jeder Methode, Klasse und sogar Imports gefoldet werden, ohne dass man vorher erst eine region deklarieren muss!

[edit]
Wenn du Eclipse verwenden solltest: MainMenu->Window->Preferences->Java->Editor->Folding
[/edit]

bye Saxony


----------



## musiKk (3. Jul 2008)

Oder anders gesagt: Wenn eine Methode etwas ausladender wird, dann ist sie schlicht zu lang. Dass Microsoft das mit einer Praeprozessordirektive unterstuetzt, find ich interessant.


----------



## Gast2 (3. Jul 2008)

Moin,



			
				Saxony hat gesagt.:
			
		

> Wenn du Eclipse verwenden solltest: MainMenu->Window->Preferences->Java->Editor->Folding



Eclipse bietet Dir das aber nur für *eine* Methode an ... unter Visual Studio funktioniert das für mehrere Methoden (auch für For-Schleifen, If's, etc.)

```
#region " Operation mit A "
public void fooWithA() { /* nüschts */ }
public void barWithA() { /* nüschts */ }
#endregion
#region " Operation mit B "
public void fooWithB() { /* nüschts */ }
public void barWithB() { /* nüschts */ }
#endregion
```

das ergibt dann unter VS2003+


```
+ Operationen mit A
+ Operationen mit B
```

oder


```
#region " Operation mit A "
public void fooWithA() { /* nüschts */ }
public void barWithA() { /* nüschts */ }
#endregion
+ Operationen mit B
```

oder


```
+ Operationen mit A
#region " Operation mit B "
public void fooWithB() { /* nüschts */ }
public void barWithB() { /* nüschts */ }
#endregion
```

Du kannst also Deine Klasse nochmal mit dem Folding sematisch zusammen fassen ... ich hatte vor kurzer Zeit auch mal danach gefragt ... die Antwort war "ja, aber selber machen, gibt noch kein Plugin dafür"

hand, mogel


----------



## Wildcard (3. Jul 2008)

mogel hat gesagt.:
			
		

> Du kannst also Deine Klasse nochmal mit dem Folding sematisch zusammen fassen ... ich hatte vor kurzer Zeit auch mal danach gefragt ... die Antwort war "ja, aber selber machen, gibt noch kein Plugin dafür"


Korrekt. Der Extension Point dafür lautet 
org.eclipse.jdt.ui.foldingStructureProviders
JDT bietet das wohl auch deshalb nicht an, weil es ein total unnötiges Feature ist.
Wofür gibt es die Outline und die Focused UI von Mylin. Warum sollte man den Quellcode mit soetwas verunreinigen wollen?


----------



## Saxony (4. Jul 2008)

Wildcard hat gesagt.:
			
		

> JDT bietet das wohl auch deshalb nicht an, weil es ein total unnötiges Feature ist. ...
> Warum sollte man den Quellcode mit soetwas verunreinigen wollen?



Richtig!  :lol:


----------



## maki (4. Jul 2008)

musiKk hat gesagt.:
			
		

> Oder anders gesagt: Wenn eine Methode etwas ausladender wird, dann ist sie schlicht zu lang. Dass Microsoft das mit einer Praeprozessordirektive unterstuetzt, find ich interessant.


Ich find's schlecht.

Wenn eine Methode zu lang ist, ist sie schlecht zu lesen und macht mehr Dinge selbst die wohl besser ausgelagert werden sollten, schlechtes OO Design -> lange Methoden sind prima Kandidaten für Refactoring.

Das MS den Entwickler da noch unterstützt schlechten Code zu schreiben wundert mich zwar nicht aber gut ist es nicht.


----------

