[C#] Problema e classi

[DeAndreon]

Salve, io vengo vengo dalla programmazione imperativa e studiare il c# che ha anche la programmazione ad oggetti mi sta mandando in una confusione pazzesca! Ecco il listato:

using System;
using System.Collections.Generic;
using Microsoft.Xna.Framework;
using Microsoft.Xna.Framework.Audio;
using Microsoft.Xna.Framework.Content;
using Microsoft.Xna.Framework.GamerServices;
using Microsoft.Xna.Framework.Graphics;
using Microsoft.Xna.Framework.Input;
using Microsoft.Xna.Framework.Net;
using Microsoft.Xna.Framework.Storage;

//Quì sopra avremo specificato diversi dei namespace di XNA e non solo (System è sempre lì).
//Per ora molti di questi namespace sono inutili e provvederemo a cancellarli.

namespace tutorial_XNA
{
public class Game1 : Microsoft.Xna.Framework.Game // <-- La classe principale del nostro gioco: Game1.
{
GraphicsDeviceManager graphics; //<-- Dichiara la classe GraphicsDeviceManager, una classe di XNA indispensabile.
SpriteBatch spriteBatch; //<-- Dichiara la classe SpriteBatch, un'altra classe di XNA necessaria per il 2D.

public Game1() //<-- Questo è il nostro "costruttore", vedremo a cosa serve. Anche lui è necessario.
{
graphics = new GraphicsDeviceManager(this);
Content.RootDirectory = "Content";
}




protected override void Initialize()
{
// Dentro a questo metodo metteremo il codice che vorremmo venga eseguito all'avvio.
// Infatti, questo metodo viene eseguito solo all'apertura del programma.

base.Initialize();
}



protected override void LoadContent()
{
// Dentro a questo metodo caricheremo i contenuti del nostro gioco, modelli, immagini ecc..
//Anche questo metodo viene eseguito solo all'inizio del programma.
spriteBatch = new SpriteBatch(GraphicsDevice); <-- Assegnamo alla variabile spriteBath un nuovo SpriteBatch.
}



protected override void UnloadContent()
{
// Dentro questo metodo elimineremo i contenuti quando non ci serviranno più, per liberare memoria.
}



protected override void Update(GameTime gameTime)
{
/* Questo metodo è molto importante, esso viene eseguito ed aggiornato continuamente(updated)
ad ogni fotogramma del gioco. All'interno di esso andrà tutto il codice
che riguarderà "l'azione" del gioco. */

/* La riga sottostante è messa di default da XNA all'interno del metodo Update.
E' in if che serve per chiudere il nostro gioco se si eseguisse su XBOX.
Noi, per ora provvederemo subito a cancellarla */
if (GamePad.GetState(PlayerIndex.One).Buttons.Back == ButtonState.Pressed) <--Se premuto il tasto..
this.Exit(); <--esci.

base.Update(gameTime);
}




protected override void Draw(GameTime gameTime)
{

/* Questo è il metodo Draw che rende possibile la visualizzazione di ogni cosa sullo schermo, Draw disegna su schermo
i nostri modelli, le nostre immagini ecc.. */

// La riga sottostante provvede a cancellare il fotogramma precedente a quello corrente..
graphics.GraphicsDevice.Clear(Color.CornflowerBlue);

base.Draw(gameTime);
}
}
}


Allora, penso di aver capito il concetto di classe e di oggetto, correggetemi se sbaglio Allora, la classe è una porzione di codice del programma che contiene i medoti(tipo funzioni come nel c e visual basic) e gli attributi(la guida che leggo io li definisce variabili). E da una classe possiamo far derivare tanti oggetti diversi tra loro oppure uguali e li possiamo differenziare tramite parametri. Penso di aver capito questo Ora il mio problema sta in quel codice...

1) che differenza c'è tra "spriteBatch = new SpriteBatch(GraphicsDevice);" e il costruttore "public Game1()"?

2) che differenza c'è tra "Game1 game = new Game1()" e public Game1() e tra "spriteBatch = new SpriteBatch(GraphicsDevice);"

3)"spriteBatch = new SpriteBatch(GraphicsDevice);" con questa(penso) inizializzazione mettiamo l'oggetto in una variabile?

4) i metodi del listato come "protected override void UnloadContent()" e gli altri appartengono alla classe creata. Ma appartengono alla superclasse da cui viene la classe creata oppure sono stati creati dall'autore del tutorial?

Spero di non creare confusione anche a chi leggerà Ho le idee confuse

Grazie del futuro aiuto!


p.s. i tutorial è questo http://www.wilez.it/tutorials/XNA/

[FixFixFix]

mi sa che hai le idee molto confuse, perchè non inizi con un tutorial base che ti spieghi i concetti di classe, costruttore, attributi, metodi, ecc ??

partire da un tutorial su grafica 2d non mi sembra saggio.

cmq

1) che differenza c'è tra "spriteBatch = new SpriteBatch(GraphicsDevice);" e il costruttore "public Game1()"?

- la prima è la creazione di un'oggetto di una certa classe, la seconda è la chiamata del costruttore di una classe

2) che differenza c'è tra "Game1 game = new Game1()" e public Game1()

quando fai la new di una classe , viene chiamato il rispettivo costruttore, quindi eseguendo la prima istruzione verrà chiamata automaticamente la seconda

3)"spriteBatch = new SpriteBatch(GraphicsDevice);

creazione di un oggetto, passando GraphicsDevice al costruttore della classe SpriteBatch

4) i metodi del listato come "protected override void UnloadContent()" e gli altri appartengono alla classe creata. Ma appartengono alla superclasse da cui viene la classe creata oppure sono stati creati dall'autore del tutorial?

sono creati dall'autore del tutorial facendo l'override dei metodi che esistono nella "superclasse" ( non si usa come temrine in c# )

[DeAndreon]

Ciao e grazie per la risposta! Stamattina mi sono applicato ancora e ho capito che gli oggeti si creano ad esempio così:

"spriteBatch = new SpriteBatch(GraphicsDevice);

Mi rimangono solo alcuni dubbi. Sono questi:

1) allora, il costruttore "inizializza"? cioè crea sia un oggetto come nell'istruzione che ho scritto sopra e può mettere in memoria una classe come per esempio "public Game1() "?

2) "Game1 game = new Game1()" significa che creo un oggetto della classe Game1 e lo metto un una variabile game? E perchè a differenza di

"spriteBatch = new SpriteBatch(GraphicsDevice)"

affianco a game c'è Game1?

3)nel tutorial prima c'è questo listato:

using System; //Aggiungo System

class Evviva //Apro la classe Evviva
{
static void Main() //Apro il metodo Main
{
Console.WriteLine("Evviva il C# e XNA!"); //Chiamo la classe Console e utilizzo il metodo WriteLine
} //Chiudo il medodo Main
} //Chiudo la classe Evviva

qui costruttori non ce ne sono ma quando eseguo il programma funziona lo stesso... Forse perchè c'è la main? oppure perchè i costruttori si utilizzano per creare oggetti con parametri? Su un altro libro ho letto che il costruttore se non specificato dal programmatore, viene richiamato di default dal compilatore... E' questo che accade in questo listato e perciò funziona il programma? quindi viene automaticamente creato l'oggetto della classe Evviva?

4) riguardante sempre il listato sopra:

Console.WriteLine("Evviva il C# e XNA!");

questo è un metodo della classe Console e si chiama WriteLine. Io so che per richiamare un metodo bisogna mettere così: variabile_contenente_oggetto.metodo(parametri)...
Come mai qua invece al posto della variabile contenente l'oggetto si mette invece la classe Console?

5) 5 e ultimo dubbio Allora, in quel metodo sopra è stata passata una stringa. Ho visto che invece in altri metodo vengono addirittura passe variabili contenenti oggetti! Allora mi chiedo: la variabile contenente l'oggetto contiene anche i risultati di eventuali chiamate dei metodi dell'oggetto stesso?

Grazie per il futuro aiuto! Spero di non scocciarti

[alex783]

Ascolta, lascia stare, non iniziare in 4a, se vuoi cominciare a studiare C#, studia questa dispensa: http://alancla.110mb.com/downloads/A...rammazione.zip

[DeAndreon]

L'archivio non funziona... Cmq le basi di programmazione le ho(di quella procedurale come Visual Basic e C) mentre non riesco ad entrare nella concezione di quella ad oggetti...

[Kralizek]

Originariamente inviato da DeAndreon

L'archivio non funziona... Cmq le basi di programmazione le ho(di quella procedurale come Visual Basic e C) mentre non riesco ad entrare nella concezione di quella ad oggetti...

Quindi studiati la programmazione ad oggetti prima di iniziare con XNA.

Perchè se chiedi cose come

2) "Game1 game = new Game1()" significa che creo un oggetto della classe Game1 e lo metto un una variabile game? E perchè a differenza di

"spriteBatch = new SpriteBatch(GraphicsDevice)"

affianco a game c'è Game1?

c'è poco da spiegare.

[banryu79]

Originariamente inviato da DeAndreon

...mentre non riesco ad entrare nella concezione di quella ad oggetti...

Sinceramente credo che sia per due ragioni:

1) hai già imparato a pensare dal punto di vista procedurale e adesso ti viene più facile vedere le cose da questa prospettiva;

2) per avere cognizione di causa con il nuovo paradigma occorre ben più che qualche ora spesa davanti a un sorgente. Se veramente vuoi approcciare la programmazione Object Oriented secondo me devi munirti di un buon libro sull'argomento ed essere pronto ad affrontare le cose con pazienza.

Dicono che non basti studiare e imparare bene un linguaggio object oriented per essersi anche impadroniti della relativa prospettiva... nel mio piccolo posso dirti che è vero (le mie prime esperienze di programmazione le ho fatte con il linguaggio C e C++, ora lavoro con Java).

[DeAndreon]

Purtroppo si, ho imparato a ragionare in modo procedurale in questi anni di studio a scuola... Sono stato sempre contro al Visual Basic tanto che ho avuto discussione anche con la prof Ora, sto sbattendo la testa ancora su un altro tutorial che spiega veramente il tutto con il cucchiaino e infatti ho capito molto!
Solo che quando torno a quel tutorial del C# e XNA trovo certe cose che mi fanno avere dubbi...

Questo tutorial è veramente per chi non ha mai programmato: http://www.docenti.org/Corsi/c/c_intro.htm

E infatti ho capito come si instanza un oggetto e ho capito finalmente la definizione di classe in modo chiaro e completo.

Ora, facendo il confronto tra i due tutorial(tra questo e quello del C# e XNA) ho dei dubbi...

Allora, in questo tutorial non si parla di costruttori ma in quell'altro (sempre quello del XNA e C#) si però che non sono riuscito a capire.

Allora, penso di aver capito che un costruttore instanza la classe, giusto?

Allora mi domano : scrivere questo "Progetto prog = new Progetto();" non è la stessa cosa di "spriteBatch = new SpriteBatch(GraphicsDevice)"?

Sempre nel listato del tutorial c'è :

GraphicsDeviceManager graphics;
SpriteBatch spriteBatch;

sono dichiarazioni di oggi(così ho letto)... cosa consiste? serve per allocare la memoria per le future instanze degli oggetti della classe?

L'ultimo dubbio è che compilando sempre il famoso listato funziona e so che la Main() sta in un altro listato(altrimenti non funzionerebbe). Mi chiedo: l'elaborazione del listato come funziona? Cioè viene prima "costruita la classe" col costruttore e poi che avviene? come vengono eseguiti gli altri metodi?

Grazie a coloro che mi risponderanno!

[DeAndreon]

Dopo un pomeriggio a sbattere la testa(nn ho rotto il monitor, non vi preoccupate ) ho capito tantissime cose! Ora ho le idee più chiare. Un unico dubbio mi rimane:

questo è il listato principale:

using System;
using System.Collections.Generic;
using Microsoft.Xna.Framework;
using Microsoft.Xna.Framework.Content;
using Microsoft.Xna.Framework.GamerServices;
using Microsoft.Xna.Framework.Graphics;
using Microsoft.Xna.Framework.Input;

namespace tutorial_XNA
{

public class Game1 : Microsoft.Xna.Framework.Game
{
GraphicsDeviceManager graphics;
SpriteBatch spriteBatch;
Texture2D imm_folletto;
Vector2 posizione;

public Game1()
{
graphics = new GraphicsDeviceManager(this);
Content.RootDirectory = "Content";
}


protected override void Initialize()
{
spriteBatch = new SpriteBatch(GraphicsDevice);
posizione = new Vector2(0f, 0f);

base.Initialize();
}


protected override void LoadContent()
{
imm_folletto = Content.Load<Texture2D>("Immagini/folletto");
}


protected override void UnloadContent()
{

}


protected override void Update(GameTime gameTime)
{

base.Update(gameTime);
}


protected override void Draw(GameTime gameTime)
{
graphics.GraphicsDevice.Clear(Color.CornflowerBlue);

spriteBatch.Begin(SpriteBlendMode.AlphaBlend, SpriteSortMode.Deferred, SaveStateMode.SaveState);
spriteBatch.Draw(imm_folletto, posizione, Color.White);
spriteBatch.End();

base.Draw(gameTime);
}
}
}

e qui invece c'è il metodo Main():



Quello che mi chiedo è: nel metodo Main viene creato l'oggetto della classe Game1 e fin qua ci sono. Poi guardando la classe Game1 vedo il suo costruttore. Li porta questo:

graphics = new GraphicsDeviceManager(this);
Content.RootDirectory = "Content";

Quindi, l'oggetto della classe creata dovrebbe avere all'interno l'oggetto graphics derivato dalla classe GraphicsDeviceManager(riferito all'oggetto della classe con this) e Content.RootDirectory = "Content". Ora, gli altri metodi della classe, come vengono richiamati? In pratica questo listato mostra l'immagine folletto a video e funziona! Però non capisco quando vengono richiamati questi metodi per la sua visualizzazione :S L'oggetto creato dovrebbe contenere solo questo(da quanto ho capito):

graphics = new GraphicsDeviceManager(this);
Content.RootDirectory = "Content";

come vengono richiamati gli altri metodi?

p.s. penso di aver svelato un mistero per me Prima avevo postato:

2) "Game1 game = new Game1()" significa che creo un oggetto della classe Game1 e lo metto un una variabile game? E perchè a differenza di

"spriteBatch = new SpriteBatch(GraphicsDevice)"

affianco a game c'è Game1?

ho capito che dichiarando prima l'oggetto con "SpriteBatch spriteBatch;" non occorre ripetre SpriteBatch affianco a "spriteBatch = new SpriteBatch(GraphicsDevice)" in quanto è già stato dichiarato (correggetemi se sbaglio )
Poi ho capito che per usare i metodi della classe bisogna prima creare gli oggetti e dopo si possono richiamare(sto facendo progressi? )

Grazie a tutti coloro che mi aiuteranno a risolvere questo dubbio!

[tomminno]

Originariamente inviato da banryu79

Sinceramente credo che sia per due ragioni:

1) hai già imparato a pensare dal punto di vista procedurale e adesso ti viene più facile vedere le cose da questa prospettiva;

Il problema è che se veramente avesse capito la programmazione procedurale non avrebbe dubbi sulle modalità di allocazione di una classe.
L'allocazione dinamica c'è anche nel procedurale.

I dubbi riguardo la programmazione ad oggetti dovrebbero essere ben altri.

[banryu79]

Originariamente inviato da tomminno

Il problema è che se veramente avesse capito la programmazione procedurale non avrebbe dubbi sulle modalità di allocazione di una classe.
L'allocazione dinamica c'è anche nel procedurale.

I dubbi riguardo la programmazione ad oggetti dovrebbero essere ben altri.

Per questo ho scritto anche il punto 2) che è quello più significativo.

[DeAndreon]

"Il problema è che se veramente avesse capito la programmazione procedurale non avrebbe dubbi sulle modalità di allocazione di una classe.
L'allocazione dinamica c'è anche nel procedurale.

I dubbi riguardo la programmazione ad oggetti dovrebbero essere ben altri."


Forse non l'ho studiato o non me lo ricordo ma l'unico dubbio che mi rimane è quello che ho postato nell'ultimo post. C'è qualcuno che gentilmente mi aiuta a capire e a risolvere questo dubbio? (le lacune posso anche "tapparle" studiando però vorrei prima capire questo dubbio che non mi riesco a spiegare)

[tomminno]

Originariamente inviato da DeAndreon

come vengono richiamati gli altri metodi?

Sei partito da un esempio un pò troppo difficile.
Se guardi quel codice trovi la parola chiave "override" davanti a vari metodi. Quelli sono metodi che ridefiniscono il comportamento della classe base Microsoft.Xna.Framework.Game. E' XNA a richiamare opportunamente quei metodi, per capire come e quando vengono richiamati dovresti studiare XNA.
Ad esempio per Draw la documentazione riporta:
Called when the game determines it is time to draw a frame.

[DeAndreon]

Ora capisco... mmmmmmmmmmmm dovrei controllare i metodi xna per svelare questo mistero... controllo e faccio sapere!

Grazie per avermi risposto!