C#: Public variabel problem

[Leif.ross]

Hei, har ett lite problem, har to public class filer, en som har en variabel jeg har lyst til å dele med den andre, har satt den som:

 

public float jumpon;

 

Og den funker helt fint i den classen, men når jeg skal bruke den variabelen i den andre classen, så vil den bare ikke funke, får feilmeldingen, the name jumpon does not exist in the current context,

 

Er overtrøtt og trenger desperat hjelp! så hadde vært supert med noen hint i riktig retning!

[Matsemann]

Selve variabelen hører jo til en instans av klassen. Skal den være skikkelig global må du gjøre den static.

[Leif.ross]

altså, holder det med å deklarere den som:

 

public static float jumpon;

 

og så kan den brukes som en vanlig variabel uten å deklarere den i den andre classen?

 

eller er det mer som skal til?

[Matsemann]

Jeg kan ikke C#, men om de følger samme OOP regler som java blir det slik:

public class Klasse1 {
public static float jumpon;
// kode

}

public class Klasse2 {
// kode

minFloat = Klasse1.jumpon;
}

 

Men hva prøver du å oppnå? For kan være bedre måter å løse dette på, avhengig av hvordan strukturen er.

 

Annen måte:

public class Klasse1 {
private float jumpon;
// kode
public float getJumpon() {
return jumpon;
}
}

public class Klasse2 {
Klasse1 minKlasse1 = new Klasse1();

// kode
minFloat = minKlasse1.getJumpon();
}

 

Men om du ikke ser noen av de her som logiske eller helt skjønner hva dem gjør tror jeg du løser problemet ditt på en feil måte i forhold til hva du kan.

[Leif.ross]

ah, yess, takker!

 

vell, har en class som tar seg av tastaturtrykk og div logikk, og en class som spiller media osv, så har en variabel i logikk delen, når den blir 1, skal det spilles av en lyd i media delen. lydavspillingen og selve variabelen funker helt fint, men de vil ikke snakke sammen liksom!

[GeirGrusom]

static:

public class RefClass
{
 public static float JumpOn { get; set; }
}

static class MainClass
{
 static void Main()
 {
   RefClass.JumOn = 1.0f;
 }
}

 

Ikke static:

public class RefClass
{
 public float JumpOn { get; set; }
}

static class MainClass
{
 static void Main()
 {
   RefClass my_ref = new RefClass();
   my_ref.JumpOn = 1.0f;
 }
}

 

Singleton:

public class SingletonClass
{
 public static SingletonClass Instance { get; private set; }
 public float JumpOn { get; set; }
 static SingletonClass()
 {
   Instance = new SingletonClass();
 }
 private SingletonClass()
 {
 }
}

static class MainClass
{
 static void Main()
 {
   SingletonClass.Instance.JumpOn = 1.0f;
 }
}

 

Const:

public class ConstClass
{
 public const float JumpOn = 1.0f;
}

public class MainClass
{
 static void Main()
 {
   float my_jumpon = ConstClass.JumpOn;
 }
}

 

Readonly:

public class ReadonlyClass
{
 public static readonly float JumpOn = 1.0f;
}

static class MainClass
{
 static void Main()
 {
   float my_jumpon = ReadonlyClass.JumpOn;
 }
}

 

 

Hvilken du skal bruke til hva avhenger fullstendig av hva du vil gjøre. En grunnregel er å ikke bruke static eller andre globale variabler med mindre du MÅ.

Static vil si at innholdet er lagret i datatypen, ikke static vil si at den blir lagret i instansen.

 

For å lage en ny instans bruker du new.

Endret 25. mai 2011 av GeirGrusom

[Leif.ross]

Ah, sweet, takker og bukker!

[Matsemann]

Skal den bare være heltall, 0, 1, 2 osv. ville jeg brukt int isteden for float. Skal den bare være 0 og 1 ville jeg brukt en boolean.

 

Ønsker man å få et objekt (klasse) til å reagere på endringer i et annet objekt kan man implementere en form for observatør/observert-teknikk (listener). Slik at når variabelen i logikk-delen endres, sier den i fra til media-delen. Så slipper media-delen å konstant måtte sjekke om logikk-variabelen har blitt endret. Men om du ikke har vært borti det før kan det være litt overkill for noe så lite, men anbefaler deg å sette deg inn i det til senere bruk.

[GeirGrusom]

Ønsker man å få et objekt (klasse) til å reagere på endringer i et annet objekt kan man implementere en form for observatør/observert-teknikk (listener). Slik at når variabelen i logikk-delen endres, sier den i fra til media-delen. Så slipper media-delen å konstant måtte sjekke om logikk-variabelen har blitt endret. Men om du ikke har vært borti det før kan det være litt overkill for noe så lite, men anbefaler deg å sette deg inn i det til senere bruk.

Jepp.

 

public class ObserverClass
{
 public event EventHandler JumpOnChanged;
 private float jump_on;
 public float JumpOn
 {
   get { return jump_on; }
   set 
   {
     jump_on = value;
     if(value != jump_on && JumpOnChanged != null)
       JumpOnChanged(this, EventArgs.Empty);
   }
 }
}

static class MainClass
{
 static void Main()
 {
   ObserverClass observer = new ObserverClass();
   observer.JumpOnChanged += new EventHandler(OnJumpOnChangedHandler);
   observer.JumpOn = 1.0f;
 }
 static void OnJumpOnChangedHandler(object sender, EventArgs e)
 {
   Console.WriteLine("JumpOn value changed to " + (sender as ObserverClass).JumpOn.ToString());
 }
}

 

Jeg har unngått lambda og type inference med vilje.

Endret 25. mai 2011 av GeirGrusom

[Matsemann]

Der du skriver

public float JumpOn {

// kode

 

hva gjøres der? (hva heter det, så kan jeg evt. søke opp selv).

[Leif.ross]

Hoveddelen:

using System;
using System.Collections.Generic;
using System.Linq;
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.Media;

namespace TheWizard
{
   /// <summary>
   /// This is the main type for your game
   /// </summary>
   public class Game1 : Microsoft.Xna.Framework.Game
   {










       GraphicsDeviceManager graphics;
       SpriteBatch spriteBatch;
       //grass
       Sprite mBackgroundOne;
       Vector2 mScaleB = new Vector2(5, 1);
       Vector2 mPositionB = new Vector2(0, 408);
       Texture2D mSpriteTextureB;
       //sun
       Sprite mSunOne;
       Vector2 mPositionS = new Vector2(300, 50);
       Texture2D mSpriteTextureS;
       Vector2 mScaleS = new Vector2(1, 1);


       //song

       Song nameofyoursong;
       bool songstart = false;

       //jump sound effect



       public SoundEffect jumpingSound;


       Wizard mWizardSprite;

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

           Wizard my_ref = new Wizard();
           my_ref.jumpon = 1.0f;

       }

       /// <summary>
       /// Allows the game to perform any initialization it needs to before starting to run.
       /// This is where it can query for any required services and load any non-graphic
       /// related content.  Calling base.Initialize will enumerate through any components
       /// and initialize them as well.
       /// </summary>
       protected override void Initialize()
       {
           // TODO: Add your initialization logic here
           mBackgroundOne = new Sprite();
           mSunOne = new Sprite();


           base.Initialize();
       }

       /// <summary>
       /// LoadContent will be called once per game and is the place to load
       /// all of your content.
       /// </summary>
       protected override void LoadContent()
       {
           // Create a new SpriteBatch, which can be used to draw textures.
           spriteBatch = new SpriteBatch(GraphicsDevice);


           mSpriteTextureB = this.Content.Load<Texture2D>("Grass");
           mSpriteTextureS = this.Content.Load<Texture2D>("Sun");

           mWizardSprite = new Wizard();
           mWizardSprite.LoadContent(this.Content);

           nameofyoursong = Content.Load<Song>("Song");


           MediaPlayer.IsRepeating = true;

            jumpingSound = Content.Load<SoundEffect>("Jump");


       }

       /// <summary>
       /// UnloadContent will be called once per game and is the place to unload
       /// all content.
       /// </summary>
       protected override void UnloadContent()
       {
           // TODO: Unload any non ContentManager content here
       }

       /// <summary>
       /// Allows the game to run logic such as updating the world,
       /// checking for collisions, gathering input, and playing audio.
       /// </summary>
       /// <param name="gameTime">Provides a snapshot of timing values.</param>
       protected override void Update(GameTime gameTime)
       {
           // Allows the game to exit
           if (GamePad.GetState(PlayerIndex.One).Buttons.Back == ButtonState.Pressed)
               this.Exit();



           mWizardSprite.Update(gameTime);



           if (!songstart)
           {
               MediaPlayer.Play(nameofyoursong);
               songstart = true;
           }

           if (jumpon == 1) 
           {
               jumpingSound.Play();

           }


           base.Update(gameTime);
       }

       /// <summaryXX>
       /// This is called when the game should draw itself.
       /// </summary>
       /// <param name="gameTime">Provides a snapshot of timing values.</param>
       protected override void Draw(GameTime gameTime)
       {
           GraphicsDevice.Clear(Color.White);

           spriteBatch.Begin();

           //spriteBatch.Draw(mSpriteTextureB, mPositionB, Color.White);
           mWizardSprite.Draw(this.spriteBatch);

           spriteBatch.Draw(mSpriteTextureB, mPositionB,
                            null, Color.White,
                            0, new Vector2(0,0), mScaleB,
                            SpriteEffects.None, 1);

           spriteBatch.Draw(mSpriteTextureS, mPositionS,
                             null, Color.White,
                             0, new Vector2(-600, 100), new Vector2(0.5f, 0.5f),
                             SpriteEffects.None, 1);

           spriteBatch.End();

           base.Draw(gameTime);
       }
   }
}

 

og her er logikk delen

 

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



namespace TheWizard
{


  public class Wizard : Sprite
   {
       List<Bullet> mBullets = new List<Bullet>();

       ContentManager mContentManager;



           public float jumpon { get; set; }









       Vector2 mStartingPosition = Vector2.Zero;
       const string WIZARD_ASSETNAME = "Wizard";
       const int START_POSITION_X = 125;
       const int START_POSITION_Y = 355;
       const int WIZARD_SPEED = 160;
       const int MOVE_UP = -1;
       const int MOVE_DOWN = 1;
       const int MOVE_LEFT = -1;
       const int MOVE_RIGHT = 1;

       enum State
       {
           Walking,
           Jumping
       }
       State mCurrentState = State.Walking;

       Vector2 mDirection = Vector2.Zero;
       Vector2 mSpeed = Vector2.Zero;

       KeyboardState mPreviousKeyboardState;

       public void LoadContent(ContentManager theContentManager)
       {
           mContentManager = theContentManager;

           foreach (Bullet aBullet in mBullets)
           {
               aBullet.LoadContent(theContentManager);
           }

           Position = new Vector2(START_POSITION_X, START_POSITION_Y);
           base.LoadContent(theContentManager, WIZARD_ASSETNAME);


       }

       public void Update(GameTime theGameTime)
       {
           KeyboardState aCurrentKeyboardState = Keyboard.GetState();

           UpdateMovement(aCurrentKeyboardState);
           UpdateJump(aCurrentKeyboardState);
           UpdateBullet(theGameTime, aCurrentKeyboardState);
           mPreviousKeyboardState = aCurrentKeyboardState;

           base.Update(theGameTime, mSpeed, mDirection);
       }
       //shooting
       private void UpdateBullet(GameTime theGameTime, KeyboardState aCurrentKeyboardState)
       {
           foreach (Bullet aBullet in mBullets)
           {
               aBullet.Update(theGameTime);
           }

           if (aCurrentKeyboardState.IsKeyDown(Keys.LeftControl) == true && mPreviousKeyboardState.IsKeyDown(Keys.LeftControl) == false)
           {
               ShootBullet();
           }
       }

       private void ShootBullet()
       {
           if (mCurrentState == State.Walking)
           {
               bool aCreateNew = true;
               foreach (Bullet aBullet in mBullets)
               {
                   if (aBullet.Visible == false)
                   {
                       aCreateNew = false;
                       aBullet.Fire(Position + new Vector2(Size.Width / 2,-10+ Size.Height / 2),
                           new Vector2(200, 0), new Vector2(2*Dir, 0));
                       break;
                   }
               }

               if (aCreateNew == true)
               {
                   Bullet aBullet = new Bullet();
                   aBullet.LoadContent(mContentManager);
                   aBullet.Fire(Position + new Vector2(Size.Width / 2,-10+ Size.Height / 2),
                       new Vector2(200, 200), new Vector2(2*Dir, 0));
                   mBullets.Add(aBullet);
               }
           }
       }

       public override void Draw(SpriteBatch theSpriteBatch)
       {
           foreach (Bullet aBullet in mBullets)
           {
               aBullet.Draw(theSpriteBatch);
           }
           base.Draw(theSpriteBatch);
       }

       //jumping
       private void Jump()
       {
           if (mCurrentState != State.Jumping)
           {
               mCurrentState = State.Jumping;
               mStartingPosition = Position;
               mDirection.Y = MOVE_UP*2;
               mSpeed = new Vector2(WIZARD_SPEED, WIZARD_SPEED);

           }

       }


       private void UpdateJump(KeyboardState aCurrentKeyboardState)
       {

           if (Position.X > 800) { Position.X = -100; }
           if (Position.X < -100) { Position.X = 800; }


           if (mCurrentState == State.Walking)
           {
               if (aCurrentKeyboardState.IsKeyDown(Keys.Space) == true && mPreviousKeyboardState.IsKeyDown(Keys.Space) == false)
               {
                   Jump();
                   jumpon = 1;
               }
               else { jumpon = 0; }



           }

           if (mCurrentState == State.Jumping)
           {
               if (mStartingPosition.Y - Position.Y > 150)
               {
                   mDirection.Y = MOVE_DOWN * 2;

               }


               if (Position.Y > mStartingPosition.Y)
               {
                   Position.Y = mStartingPosition.Y;
                   mCurrentState = State.Walking;
                   mDirection = Vector2.Zero;
               }
           }
       }

       private void UpdateMovement(KeyboardState aCurrentKeyboardState)
       {
           if (mCurrentState == State.Walking)
           {
               mSpeed = Vector2.Zero;
               mDirection = Vector2.Zero;


               if (aCurrentKeyboardState.IsKeyDown(Keys.Left) == true)
               {
                   mSpeed.X = WIZARD_SPEED;
                   mDirection.X = MOVE_LEFT;
                   Heading = SpriteEffects.None;
                   Dir = -1;
               }
               else if (aCurrentKeyboardState.IsKeyDown(Keys.Right) == true)
               {
                   mSpeed.X = WIZARD_SPEED;
                   mDirection.X = MOVE_RIGHT;
                   Heading = SpriteEffects.FlipHorizontally;
                   Dir = 1;
               }


           }
       }
   }
}

 

Kan ikke deklarere de som static, hmm, får fortsatt samme feilen, hva gjorde jeg feil?

[GeirGrusom]

Der du skriver

public float JumpOn {

// kode

 

hva gjøres der? (hva heter det, så kan jeg evt. søke opp selv).

Getters og setters slik som i Java. egen syntaks for det i C#. Gjør at en event handler blir kalt dersom verdien endrer seg.

[Matsemann]

Okey, slik man gjør det i C#. Egentlig litt nice, å ha det samlet slik. Men da skjønner jeg mer.

[GeirGrusom]

TS: Hvor får du feil, og hva er feilmeldingen?