[ASP.NET] Onthouden of Copy-Paste

[Swerfer]

Ik zit met het volgende:

Ik kan behoorlijke web applicaties schrijven in ASP.NET, maar meer dan 50% van de code is copy past van voorbeelden van internet/MSDN die ik dan aanpas aan mijn wensen. Ik heb grote moeite om al de classes uit de Class Library te onthouden, laat staan dat ik kan onthouden wat ik met die classes allemaal kan doen.

Puur het programmeren van in mijn geval VB daar heb ik totaal geen moeite mee, dat zit ergens in mijn grijze massa ingebakken.

Hoe programmeren jullie ASP.NET (of andere OO programmeertalen)? Leren jullie al die classes met hun mogelijkheden uit je kop, of denk je: Ik wil zus of zo maken, daar is vast wel een class voor met een voorbeeld, dus ik ga maar zoeken in MSDN/Internet? Of hebben jullie een boek als naslagwerk, of misschien een zelfgeschreven naslagwerk met veel voorkomende classes?

Ik kopieer zelf vaak mijn eigen werk. Heb ik een stuk code nodig die ik al eerder geschreven heb, dan copy-past maar weer Dit werkt natuurlijk prima, maar daarmee leer je in ieder geval nooit zelf de zooi te onthouden...

[gorgi_19]

Een generieke class library, waar je een reference naar maakt in je project geen optie? Sowieso is er bij de voorbeelden op Internet ook een hoop bagger, dus klakloos overnemen is niet altijd een goed idee

[ Voor 41% gewijzigd door gorgi_19 op 17-04-2006 09:14 ]

[whoami]

Tja, van de classes die ik meest/veel gebruik weet ik natuurlijk wel wat ze doen; echter het komt altijd voor dat er iets is waarvan je niet precies weet welke class/method je best gebruikt, of welke method van een class nu weer wat doet. Daar heb je de MSDN voor.

Als jij zegt dat je 50% van je code copy/paste, dan denk ik dat je idd iets niet goed doet. Wat gorgi_19 zegt, is dan wel een oplossing: schrijf een generieke lib die je in je projecten kan hergebruiken. Op die manier moet je niet meer copy/pasten, en heb je die code in één assembly. (Als je bv een bug vind in je 'standaard' code, dan hoef je die enkel op 1 plek op te lossen, anders moet je al je projecten gaan overlopen.

[H!GHGuY]

euhm...

ervaring en logica denk ik...

Je weet dat collecties in de System.Collection interface staan, GUI-dingen in System.Windows.Forms, enz enz.

Verder leer je door gebruik wel veel van de klassen kennen.
Als ik bvb zie dat de compiler de PointF struct niet kent dan weet ik ondertussen wel dat ik ff de System.Drawing moet toevoegen. Anderzijds leer je door gebruik en rondbazuinen in de reference veel nieuwe dingen.

Zoeken is het begin, kennen het eind

[reddog33hummer]

Zelf hanteer ik de regel, 1 keer gewoon programeren. 2e keer kopieren 3e keer generaliseren.
Blijkbaar kopieer je gewoon zoveel dat blijft kopieren. Mischien moet je zaken beter gaan indelen.

[joopst]

Ik geef code altijd een naam zodat je aan de naam kan zien wat hij doet. De naam van de objecten probeer ik altijd zoveel mogelijk 1 op 1 te laten lopen met hoe er in de 'echte' wereld over wordt gesproken.
Op deze manier is de werking van de code hetzelfde als hoe je het zou zeggen tegen bijv. je collega.
Met deze naamgeving kan ik redelijk goed onthouden wat elk stuk code doet.
Hoe het precies geimplementeerd is, dat weet ik dan niet altijd, maar dat maakt ook niet zoveel uit, als je maar weet wat het doet.

[Verwijderd]

Wanneer je de Visual Studio IDE gebruikt hoef je toch vrijwel niks uit je hoofd te leren? Wanneer ik iets nodig heb ga ik gewoon in het framework graven, eventueel met de Object Browser.

[_Thanatos_]

De Reflector kan ook een hoop hulp bieden als je iets zoekt waarvan je denkt dat het wel in het framework zit... en je krijgt zelfs source (gedecompileerd) erbij

Reflector werkt overigens met .NET 1.1 en 2.0. En kan niet alleen het framework zelf reflecten, maar eigenlijk iedere gewenste .NET assembly

[ Voor 41% gewijzigd door _Thanatos_ op 20-04-2006 12:01 ]