Quale linguaggio....

martedì 23 settembre 2014 - 17.17
Tag Elenco Tags  C#  |  VB.NET  |  Visual Studio 2010

roninkaiser Profilo | Newbie

Buongiorno a tutti,

scrivo per ricevere un consiglio ....
per molti anni ho sviluppato piccoli gestionali (nulla di complicato) in modo procedurale utilizzando VB6 e talvolta VBA.
Poi mi sono allontanato spostandomi su altre tematiche.

Oggi vorrei ricominciare a sviluppare ma informandomi sul tema sono rimasto a bocca aperta.
Mi sembra di aver capito che i linguaggi sono quasi obbligatoriamente OOP, però vorrei (se possibile) imparare qualcosa che faccia al caso mio e dedicarmi totalmente per un po' a questo in modo da sentirmi meno obsoleto.
Non vorrei però sbagliare nella scelta e scegliere un prodotto che è già dichiarato morto in partenza.

C# VB.NET JAVA VISUAL C++ WPF WEB APP ...????

Attendo vostri consigli e opinioni!! Tenete presente che arrivo da VB6 e devo dedicarmi a piccoli gestionali.

Grazie

0v3rCl0ck Profilo | Guru

Ciao Matteo,

Se parli di gestionali che devono girare su desktop, sicuramente io personalmente punterei su WPF, perchè è maturo e di certo non un abandonware, inoltre è anche la base per lo sviluppo di applicazioni windows phone e/o windows store app (quelle di win8 per intenderci), poi è estremamente versatile con i nuovi concetti di binding che si prestano perfettamente per implementare applicazioni seguendo l' MVVM pattern (Model-View-ViewModel).

Se invece pensi a fare un gestionale diciamo multi-platform, e cioè che giri su qualsiasi device semplicemente perchè gira su diversi browser, qui la scelta ultimamente è difficile, e disperata c'è di tutto... microsoft sta per uscire con la versione stabile di asp.net vnext, che ha alla base MVC ma è stato riscritto da zero, ovviamente qui è dove MS vorrà puntare per tutto quello che è e sarà web.

Poi tu provieni da VisualBasic, quindi la scelta diretta sarebbe quella di scrivere le tue app in VB.NET, ma se sei fermo da tanto, ti consiglierei di buttarti su C# (ad ogni modo devi impararti tutta la libreria .net che è uguale sia da una parte che dall'altra), non tanto per chissà quale ragione di stile o cos'altro, non voglio entrare nelle solite controversie inutili, ma anche io scrivevo in vb tanto tempo fa, e ho trovato estremamente utile avere imparato c#, innanzitutto ti avvicina a tanti linguaggi come javascript, c, c++, objective-c, ecc... (alla fine sono tutti dialetti della stessa lingua), ma sopratutto perchè si trovano molti più esempi in c# di quanti ce ne siano in vb.net, e tanti libri che a volte trattano di argomenti come pattern di scritttura, metodologia di programmazione in generale, è più facile che contengano esempi in c#, in generale è una community più estesa, con i pro e i contro del caso io ci ho trovato più pro!



Michael Denny | Visual C# MVP
http://blogs.dotnethell.it/Regulator/
http://dennymichael.wordpress.com
http://mvp.microsoft.com/mvp/Michael%20Denny-5000735
Twitter: @dennymic

roninkaiser Profilo | Newbie

Grazie sei stato molto esaustivo e diretto (non come tanti altri).

Già che ci sono ti espongo un altro mio limite.
Essendo un po' fermo da tempo sul discorso OOP (che credo sia la base di tutto), ho fatto un corso per farmi spiegare meglio il tutto.
Ho capito bene la teoria ma quando provo a mettere in pratica ho due problemi principali:

- sviluppando piccoli applicativi desktop non riesco a riportare ciò che ho imparato nei miei piccoli progetti. Mi sembrerebbe più una cosa adatta ad un progetto vasto fatto da un team di sviluppo

- provenendo da vb6 e quindi programmazione non OOP a volte faccio fatica a ragionare con le classi.

Mi consigli qualche altro approccio per apprendere meglio la tematica? E' un problema solo mio?

Grazie

0v3rCl0ck Profilo | Guru

>- sviluppando piccoli applicativi desktop non riesco a riportare
>ciò che ho imparato nei miei piccoli progetti. Mi sembrerebbe
>più una cosa adatta ad un progetto vasto fatto da un team di
>sviluppo

in OOP ci sono tutti i linguaggi alla base di .net (ad eccezione di F# che è anche un linguaggio funzionale e imperativo), ma il concetto è che non ti devi fare spaventare da questi "nomoni", VB.NET e C# sono OOP, ma detto questo nulla ti vieta di programmare in procedurale, sta di fatto, che il framework è scritto in OOP e quindi giustamente è meglio essere consapevoli che tutto il codice che si sfrutta si basa sull'interazione di oggetti/classi, piuttosto che di metodi su metodi distribuiti in librerie... ma più in dettaglio che certi oggetti possono acquisire comportamenti base da altri oggetti (ereditarietà), e poi tutti gli altri dogmi che ti avranno spiegato, polimorfismo, ecc... ma vabbe questi sono paroloni, e a mio avviso è buono cercare di capirli e approfondirli, ma sinceramente puoi anche impararli strada facendo, sul campo di battaglia!

>- provenendo da vb6 e quindi programmazione non OOP a volte faccio
>fatica a ragionare con le classi.

forse ti avranno fatto i classici esempi OO tipo Automobile che eredita da MezzoDiTrasporto, ecc.. questo serve per spiegare in termini umani le potenzialità di un linguaggio OOP, ma questo non vuol dire che qualsiasi cosa che scriverai deve sottostare a queste leggi "naturali", ci sono tonnellate di codice che non devono necessariamente rappresentare un entità reale, ma che sono di supporto all'intera applicazione, chiamali Service, chiamali Component, chiamali come vuoi ma sono collezioni di metodi che prima scrivevi proceduralmente, e che ora sono ben strutturati e che possono sfruttare tutto quello che C# mette a disposizione, come tutta la serie di strumenti dettati dall'OOP, quali ereditarietà, polimorfismo e incapsulamento. Questo non vuol dire che devi sempre usare tutti questi meccanismi, anche se vedrai che con il tempo li sfrutterai tutti, specialmente mano a mano che capirai a cosa possono servirti. Nel framework sono già presenti tonnelate di righe di codice scritte sfruttando quei meccanismi, un esempio pratico è lo StreamReader, è stato scritto solo una volta ed è in grado di leggere qualsiasi tipo di Stream, dove Stream è a sua volta una classe, ma una classe BASE, che definisce comportamenti base, quei comportamenti che sono sufficienti a potere estrapolare i bytes contenuti in esso, e anche a raprresentarli in una stringa, in particolare lo StreamReader si preoccupa di sapere a che punto è del file, gestisce la lettura a buffer, ed è in grado ad esempio di ritornarti tutta la stringa in un colpo solo con il metodo .ReadToEnd() ...la classe Stream NON può essere istanziata perchè appunto è un concetto astratto (abstract class), uno stream deve diventare qualcosa di concreto, quindi una sequenza di byte di un File, di una lettura da Network, di una porzione di memoria, ecc... quindi esistono appunto le specializzazioni FileStream, NetworkStream, HttpResponseStream, MemoryStream ... pensa che ce ne sono più di 60/70, e ognuno può essere dato in pasto ad uno StreamReader(Stream ...) e potere sfruttare le potenzialità dello streamreader, senza che quest'ultimo sia stato scritto 60/70 volte per ogni tipo di Stream, invece è stato sviluppato soltanto una volta... quindi qui capisci la potenza di un linguagio object-oriented.

Detto questo non farti spaventare comunque da queste cose, puoi iniziare a sviluppare partendo da esempi pratici, magari applicando già anche dei pattern, ma senza struggersi per cercare da subito di capire perfettamente cosa vogliono dire o in che cosa ti facilitano, certi sono ovvi nel momento in cui li usi.

>Mi consigli qualche altro approccio per apprendere meglio la
>tematica? E' un problema solo mio?

Potrei consigliarti di cercare qualche tutorial WPF + MVVM, dove vedrai come creare una classe VewModel che dai in pasto alla classe View nella sua proprietà DataContext, e da li puoi sfruttare il binding dai file XAML che non sono nient'altro che file come l'HTML, un meta linguaggio per rappresentare degli oggetti grafici:

http://www.codeproject.com/Articles/165368/WPF-MVVM-Quick-Start-Tutorial

http://www.markwithall.com/programming/2013/03/01/worlds-simplest-csharp-wpf-mvvm-example.html

è normale che se ti mancano tante tante basi, è difficile approcciarsi anche così, ma il mio consiglio rimane lo stesso, provare provare provare... meglio comunque mettersi alla prova, che cercare di studiare libri da copertina a copertina, anche perchè fino a che non tocchi con mano certi aspetti non li riesci a capire, i libri poi vanno benissimo, non voglio dire il contrario, ma l'approccio deve essere quello di partire con un obiettivo, e di sfruttare il libro per raggiungere l'obiettivo, quindi parti da un qualcosa di pratico, che ti serve, che ti piace, appunto come dicevi devi creare un gestionale, bene, il mio consiglio: "inizia!" ...visual studio 2013 update 3 (anche express fo windows http://www.visualstudio.com/products/visual-studio-express-vs), nuovo progetto wpf, F5 e già parte l'applicazione aprendoti la window vuota... da li imparati un po' lo XAML, ho detto XAML , non usare il designer neanche per scherzo, il designer lo puoi usare per fare cose complesse come gradienti, animazioni in blend, o cose strettamente legate alla grafica, ma non alla struttura della UI, esattamente come farebbe un buon sviluppatore web, scrive in HTML, poi applica stili ecc... non si mette a fare porcherie con un designer, anche perchè in XAML è fondamentale capire bene i vari oggetti che lo compongono, per toccare con mano le potenzialità e i comportamenti di ognuno di esso... una volta provato qualche storia in XAML (non chiedere troppo a te stesso all'inizio, una StackPanel con dentro 3 TextBlock e 1 Button è più che sufficiente, e i miei prototipi spesso non vanno mai tanto oltre ), incominci a collegarci qualche dato, e li ti si apre MVVM che è un pattern, ma non stare li tanto a farti del male con il pattern in se, piuttosto guarda bene cosa ti fanno fare dei tutorial e alla fine cerca di capire il risultato che ti da l'MVVM, e quanto è figo... ti crei una classe MainViewModel, ci metti qualche proprietà stringa, e nel costruttore le valorizzi con dati a caso, poi dallo XAML incomincia a vedere il binding, <TextBlock Text="{Binding Path=MiaProprietà}" /> e come per magia dentro alla textblock ci andrà il valore della tua proprietà del viewmodel... il viewmodel per farlo bere alla view lo devi impostare al suo datacontext... metodo veloce all'inizio senza farsi seghe mentali, giusto per provare, è nel costruttore del code-behind della View, fare tipo "this.DataContext = new MyViewModel()" fine! in questo modo ogni controllo che metterai nello XAML della view potrà vedere il tuo ViewModel quando applichi un binding.

Mi sono dilungato troppo, perchè ovviamente è un argomento vasto, ma non ti fare prendere dal panico, prova a fare qualcosa, se riesci a fare qualcosa di concreto e poi ti fermi trovando difficoltà in certi punti, ritorna sul forum e fai domande specifiche, se proprio ti blocchi pesante, allora riparti da zero, prendi qualche libro interessante tipo C# in a nutshell (io conosco solo libri in inglese, non ne leggo altri purtroppo) che ti spiega tutto il linguaggio, e poi un WPF unleashed per saperne di più su WPF, su MVVM trovi molto in rete oppure http://joshsmithonwpf.wordpress.com/advanced-mvvm/, oppure cerca qualcuno (come il sottoscritto) che ti possa fare un corso intensivo su OOP + WPF



Michael Denny | Visual C# MVP
http://blogs.dotnethell.it/Regulator/
http://dennymichael.wordpress.com
http://mvp.microsoft.com/mvp/Michael%20Denny-5000735
Twitter: @dennymic

roninkaiser Profilo | Newbie

Grazie gentilissimo e professionale.

Le potenzialità della programmazione OOP le capisco bene il problema è usarle ....
Si certo potrei continuare con un atteggiamento procedurale ma mi sentirei ancora più obsoleto.
La penso come te e mi sono sempre mosso così quando affronto le novità.
Devo raggiungere un obiettivo e ci provo, poi magari faccio 1000 domande nei forum ma la volta dopo saranno solo 100.

Mi servirebbe qualche esempio semplice, qualche programmino con uno scopo da visionare o qualche collega esperto dal quale sbirciare.

Altra tematica che mi spaventa un po' è l'accesso ai dati.
Avevo capito a malapena i discorsi legati alla modalità disconnessa e poi connessa che si facevano nel 2003....ora mi parlano di LINQ....AIUTO!!!!!!!!!

Grazie

0v3rCl0ck Profilo | Guru

si ormai parlare di modalità connessa e disconnessa è superato, ehehe se ci penso mi fa ridere come tutte le volte, nella storia della programmazione, ci siano sempre stati nuovi mostri da combattere.

più che altro il concetto rimane solo uno, se si fa una query a database, si vuole che quest'ultima venga eseguita e liberata nel minor tempo possibile, per dare la possibilità ad altre query concorrenti di sfruttare le risorse del server, senza che quest'ultimo sia tempestato di connessioni aperte a fare niente, cosa che poteva succedere con un approccio "connesso", per cui mentre si scorreva il resultset connesso ci si preoccupava anche di creare l'eventuale html (per il buon classic asp), o popolare dati in una form, ma questo porta tanti svantaggi, stai tenendo in piedi una connessione, continui a scaricare dati dallo stream aperto verso sql, e il tutto per il tempo di elaborazione di altre cose non legate all'accesso ai dati (creazione html / elementi form), quindi ora non si ragiona più in quel modo (a dire la verità è sempre stato possibile evitare quelle cose anche in linguaggi non OOP), ma semplicemente ad entità, ed è qui che l'OOP ci viene estremamente in aiuto, potendo rappresentare tutto il nostro modello database, in un modello quasi identico, anzi più potente perchè rappresentato da un grafo di classi, che può essere "navigato".

in poche parole potrai avere cose tipo:

public class User { public int UserId { get; set; } public string FirstName { get; set; } public string LastName { get; set; } public string Username { get; set; } public string Password { get; set; } public string Address { get; set; } // proprietà di navigazione che di fatto in SQL sarebbe rappresentata con una JOIN public List<Post> Posts { get; set; } }

che esprime un entità utente, con le sue proprietà, questo rappresenterà poi probabilmente una tabella simile a database.

Per fare l'accesso ai dati, attualmente ci sono davvero tante possibilità e strumenti, tra l'altro quasi tutti open-source, compreso quelli della microsoft! Ad esempio abbiamo Entity Framework della microsoft, che è un ORM (object-relational mapper) per accedere a database relazionali, oppure ugualmente anche NHibernate anch'esso open-source. Alla base di questi framework c'è sempre il buon vecchio ADO.NET, che è l'evoluzione di ADO che conoscerai... L'evoluzione dei RecordSet, sono i DataSet con i loro DataTable (ma ti prego non usarli)... i DataSet nascevano dall'esigenza di dare un qualcosa che fosse simile ai recordset per non fare sbroccare che veniva dalla vecchia programmazione, sono anche molto più potenti e possono gestire anche insert,update e delete, ma... ma non usarli, anche perchè di fatto vanno un po' contro alla pura OOP, perchè rappresentano entità diverse con la stessa classe, appunto il DataSet, che può contenere tante tabelle DataTable, utilizzando quegli oggetti si finisce per programmare con un sacco di stringhe schiantate per accedere alle colonne, non sapendo mai di che diavolo di tipo è una colonna, e sopratutto non sapere che proprietà ha una entità... invece è meglio sviluppare partendo da semplicissime classi di modello, anche chiamate POCO (Plain Old CLR Object), che è un acronimo inglese, ma in italiano rende abbastanza l'idea , infatti sono classi povere di codice, definiscono semplicemente l'entità, definendo solo le proprietà senza nessun comportamento (quindi NO metodi con codice).

un esempio di classe poco è quella che ti ho postato sopra, che puoi sfruttare per ritornare i dati dopo un accesso a database, capisci bene che avere una collezione fortemente tipizzata di User, è estremamente più comodo da utilizzare a codice, perchè invece che avere roba del tipo "dataRow["FirstName"]" di cui devi sapere l'esatta stringa del nome colonna e di cui non sai il tipo dato a priori, avere una cosa così invece è molto meglio "user.FirstName", che è compilato, non puoi sbagliare niente, perchè te lo direbbe subito in fase di compilazione.

io ti consiglio di vedere un po' ADO.NET, e poi di passare a Entity Framework 6 (EF).

per quanto riguarda ADO.NET trovi un sacco di roba cercando su google "tutorial ado.net", come questa: http://www.csharp-station.com/Tutorial/AdoDotNet
in molti esempi però fanno vedere l'uso di DataSet, per vederli male non fa, ma per me fanno più male che altro, cerca guide che ti mostrino semplicemente come funziona il SqlDataReader e il SqlCommand, che sono i due oggetti più importanti, dopo ovviamente SqlConnection ...si il SqlDataReader è l'oggetto per l'accesso ai dati "connesso", ma se carichi un oggetto come ti dicevo, e poi chiudi subito la connessione, di fatto hai implementato un metodo di accesso ai dati "sconnesso" dal momento che poi utilizzerai la tua collezione di oggetti nel resto della tua applicazione e non direttamente il sqldatareader, per questo non mi piacciono tanto le guide che si trovano in giro, perchè fanno la differenza obsoleta, di dire che sqldatareader è "connesso" e il dataset è "sconnesso", e via tutti a usare i dataset, queste affermazioni portano a fare scelte sbagliate, si il SqlDataReader è connesso, e si il DataSet è sconnesso, ma puoi usare il SqlDataReader e lavorare comunque sconnesso, basta caricare un oggetto e staccarsi nel più breve tempo possibile dal sqldatareader, e stai sicuro che caricare una tua misera classe POCO, sarà per forza di cose più veloce che caricare un dataset, perchè entrambi alla fine usano comunque un SqlDataReader, ma con la differenza che il DataSet ha migliaia di righe di codice di comportamenti che la tua piccola classe POCO non ha... io ci vedo solo vantaggi nell'usare una bella modellazione a classi in vero stile OOP

mentre per quanto riguarda entity framework (EF), qui trovi un sacco di info: http://msdn.microsoft.com/it-IT/data/ee712907
e qui trovi un bellissimo tutorial per creare un sito MVC 5 e EF 6: http://www.asp.net/mvc/tutorials/getting-started-with-ef-using-mvc/creating-an-entity-framework-data-model-for-an-asp-net-mvc-application

suggerimento con EF: approccia con uno stile Code-First piuttosto che Model-First, in pratica usando codice invece che il designer, è molto importante, perchè hai molto più controllo su quello che fai, e capisci anche molto meglio come funziona una modellazione in c# OOP, non per niente al sql saturday a Parma che ci sarà il 22 novembre terrò proprio una sessione su EF 6 Code-First:

http://www.sqlsaturday.com/viewsession.aspx?sat=355&sessionid=25373

puoi ancora iscriverti se vuoi: http://www.sqlsaturday.com/355/register.aspx


Magari prova un po' a fare qualcosa e poi incomincia ad aprire thread sul forum con richieste specifiche, su vuoi qualche esempio diretto, prova ad aprire un thread mirato "Esempi accesso ai dati con ADO.NET" / "Esempi accesso ai dati con Entity Framework (Code-First) ", in tanti hanno avuto la tua stessa esigenza, quindi qualche link utile arriverà


Michael Denny | Visual C# MVP
http://blogs.dotnethell.it/Regulator/
http://dennymichael.wordpress.com
http://mvp.microsoft.com/mvp/Michael%20Denny-5000735
Twitter: @dennymic
Partecipa anche tu! Registrati!
Hai bisogno di aiuto ?
Perchè non ti registri subito?

Dopo esserti registrato potrai chiedere
aiuto sul nostro Forum oppure aiutare gli altri

Consulta le Stanze disponibili.

Registrati ora !
Copyright © dotNetHell.it 2002-2024
Running on Windows Server 2008 R2 Standard, SQL Server 2012 & ASP.NET 3.5