C#

/// <summary> 
/// Finds the last column on a worksheet. 
/// </summary> 
/// <param name="xlWorkSheet"></param> 
/// <returns></returns> 
public string FindLastColumn(Worksheet xlWorkSheet) 
{ 
int nInLastCol = 0; 

// Find the last real column 
nInLastCol = xlWorkSheet.Cells.Find("*", System.Reflection.Missing.Value, System.Reflection.Missing.Value, 
System.Reflection.Missing.Value, XlSearchOrder.xlByColumns,XlSearchDirection.xlPrevious, 
false,System.Reflection.Missing.Value,System.Reflection.Missing.Value).Column; 

return GetExcelColumnName(nInLastCol); 
} 

/// <summary> 
/// Converts the column # to the corresponding letter. 
/// </summary> 
/// <param name="columnNumber"></param> 
/// <returns></returns> 
private string GetExcelColumnName(int columnNumber) 
{ 
int dividend = columnNumber; 
string columnName = String.Empty; 
int modulo; 

while (dividend > 0) 
{ 
modulo = (dividend - 1) % 26; 
columnName = Convert.ToChar(65 + modulo).ToString() + columnName; 
dividend = (int)((dividend - modulo) / 26); 
} 

return columnName; 
} 

/// <summary> 
/// Finds the last row on a worksheet. 
/// </summary> 
/// <param name="xlWorkSheet"></param> 
/// <returns></returns> 
public long FindLastRow(Worksheet xlWorkSheet) 
{ 
long nInLastRow = 0; 

// Find the last real row 
nInLastRow = xlWorkSheet.Cells.Find("*", System.Reflection.Missing.Value, 
System.Reflection.Missing.Value, System.Reflection.Missing.Value, 
XlSearchOrder.xlByRows,XlSearchDirection.xlPrevious, 
false,System.Reflection.Missing.Value,System.Reflection.Missing.Value).Row; 
return nInLastRow; 
}

Dim TSExcelLib As New TechSolutionsXLLibrary.ExcelFunctions 

Private Sub CommandButton1_Click() 

MsgBox TSExcelLib.FindLastColumn(Sheets("Sheet1")) 'Works 
MsgBox TSExcelLib.FindLastColumn(Sheet1) 'Works 

MsgBox TSExcelLib.FindLastColumn(Sheets("Sheet1")) 'Doesn't work 
MsgBox TSExcelLib.FindLastColumn(Sheet1) 'Doesn't work 

     using System;

namespace WindowsGame1
{
#if WINDOWS || XBOX
    static class Program
    {
        /// <summary>
        /// The main entry point for the application.
        /// </summary>
        static void Main(string[] args)
        {
            Form1 form = new Form1();
            form.Show();
            Game1 game = new Game1(form.getDrawSurface());
            //game.buttonHit(400,500, true);
            game.Run();
        }
    }
#endif
}

    public partial class Form1 : Form
    {
        public Form1()
        {
            InitializeComponent();
        }

        Game1 game1 = new Game1();
        int counter = 1;
            
                   
        public IntPtr getDrawSurface()
        {
            return pctSurface.Handle;
        }

        private void button1_Click(object sender, EventArgs e)
        {
            game1.buttonHit(350, 450, true);
            counter++;
            label1.Text = counter.ToString();
        }

    }
}

    public class Game1 : Microsoft.Xna.Framework.Game
    {
        private GraphicsDeviceManager graphics; // Används för att hantera grafik
        private SpriteBatch spriteBatch; // Används för att rita bilder
        private Player player; // Spelarens objekt  
        private Player player2; // Spelarens objekt
        private Enemy enemy;
        private Texture2D backgroundTexture;
        int screenWidth;
        int screenHeight;
        GraphicsDevice device;
        Rectangle textBox;
        private IntPtr drawSurface;
        int x;
        int y;
        bool isActive = false;
       
        public void buttonHit(int X, int Y, bool IsActive)
        {
            x = X;
            y = Y;
            isActive = IsActive;
        }

        public Game1(IntPtr drawSurface)
        {
            graphics = new GraphicsDeviceManager(this);
            Content.RootDirectory = "Content";
            this.drawSurface = drawSurface;
            graphics.PreparingDeviceSettings += new EventHandler<PreparingDeviceSettingsEventArgs>(graphics_PreparingDeviceSettings);
            System.Windows.Forms.Control.FromHandle((this.Window.Handle)).VisibleChanged += new EventHandler(Game1_VisibleChanged);
        }

        public Game1()
        { 
        
        }

        

        //param name="sender"></param>
        //<param name="e"></param>
        void graphics_PreparingDeviceSettings(object sender, PreparingDeviceSettingsEventArgs e)
        {
                e.GraphicsDeviceInformation.PresentationParameters.DeviceWindowHandle =
                drawSurface;
        }
 
        /// <summary>
        /// Occurs when the original gamewindows' visibility changes and makes sure it stays invisible
        /// </summary>
        ///
        //<param name="sender"></param>
        //<param name="e"></param>
        private void Game1_VisibleChanged(object sender, EventArgs e)
        {
                if (System.Windows.Forms.Control.FromHandle((this.Window.Handle)).Visible == true)
                    System.Windows.Forms.Control.FromHandle((this.Window.Handle)).Visible = false;
        }


        /// <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()
        {
            //Istället för att initiera (skapa startvärden) här så gör vi det i Player-klassens konstruktor.
            graphics.PreferredBackBufferWidth = 1500;
            graphics.PreferredBackBufferHeight = 800;
            graphics.IsFullScreen = false;
            graphics.ApplyChanges();
            Window.Title = "Enigma";

            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);
            device = graphics.GraphicsDevice;
            //player = new Player(Content.Load<Texture2D>("images/player/ship"), 380, 400, 2.5f, 4.5f); //Lägg till denna. Här skapar du ditt Player-objekt.
            enemy = new Enemy(Content.Load<Texture2D>("images/enemies/uboat2_small"), 0, 0);
            player = new Player(Content.Load<Texture2D>("images/player/Ship"), 300, 400);
            if (isActive == true)
                 player2 = new Player(Content.Load<Texture2D>("images/player/Ship"), x, y);

            // TODO: use this.Content to load your game content here

            backgroundTexture = Content.Load<Texture2D>("images/Background/Atlanten3_1");
            screenWidth = device.PresentationParameters.BackBufferWidth;
            screenHeight = device.PresentationParameters.BackBufferHeight;
        }

        /// <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();


            player.update(Window); // Anropa metoden update i player-klassen
            if (isActive == true)
                player2.update(Window); // Anropa metoden update i player-klassen
            //enemy.Update(Window); // Uppdatera fiendens position
     
            
                enemy.Update2(Window, x, y);

       

            base.Update(gameTime);
        }

        /// <summary>
        /// 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.CornflowerBlue);
            spriteBatch.Begin();
            DrawScenery();

            //spriteBatch.Draw(ship_texture, Vector2.Zero, Color.White); //Ta bort denna.
            player.Draw(spriteBatch); // Rita ut spelaren
            if (isActive == true)
                player2.Draw(spriteBatch); // Rita ut spelaren
            //if (player.Y <= 350)
              // enemy.Draw(spriteBatch);

            
            enemy.Draw(spriteBatch);


            spriteBatch.End();

            // TODO: Add your drawing code here

            base.Draw(gameTime);

        }

        private void DrawScenery()
        {
            Rectangle screenRectangle = new Rectangle(0, 0, screenWidth, screenHeight);
            spriteBatch.Draw(backgroundTexture, screenRectangle, Color.White);
        }
    }
}

public abstract class MovingObject : GameObject
{
    public Vector2 ship_speed; // Rymdskeppets hastighet

    // =============================================================
    // MovingObject(), konstuktor för att skapa objektet  : Ärver från konstruktorn i GameObject
    // =============================================================
    //Här äver vi från konstruktor i bas-klassen. Vi måste dock ändå skapa en konstruktor för denna klassen.
    public MovingObject(Texture2D texture, float X, float Y, float speedX, float speedY) : base(texture, X, Y)
    {
           this.ship_speed.X = speedX;
           this.ship_speed.Y = speedY;
    }
}

   }

    public class Player : MovingObject
    {
 bool isAlive = true; // För att hålla koll på om fienden lever eller inte

        public Player(Texture2D texture, float X, float Y) : base(texture, X, Y, 0.05f, 0.05f) //Sätter fart
        {
        }
     
        public void update(GameWindow window)
        {

             KeyboardState keyboardState = Keyboard.GetState();

            // Flytta rymdskeppet efter tangenttryckningar (om det inte är på
            // väg ut från kanten):
            if (ship_vector.X <= window.ClientBounds.Width - texture.Width && ship_vector.X >= 0)
                if (keyboardState.IsKeyDown(Keys.NumPad5))
                    ship_vector.X += 1;


            // Flytta på fienden:
            ship_vector.X -= ship_speed.X;
            ship_vector.Y -= ship_speed.Y;
            // Kontrollera så fienden inte åker utanför fönstret på sidorna
            if (ship_vector.X > window.ClientBounds.Width - texture.Width || ship_vector.X < 0)
                ship_speed.X *= -1; // Byt riktning på fienden
            // Gör fienden inaktiv om den åker ut där nere
            if (ship_vector.Y > window.ClientBounds.Height)
                isAlive = false;
        }
        // 
        public bool IsAlive
        {
            get { return isAlive; }
            set { isAlive = value; }
        }
    }//Here ends class



}

Enemy-class:

<pre lang="c#">

    public class Enemy : MovingObject
    {
        bool isAlive = true; 
      
        public Enemy(Texture2D texture, float X, float Y) : base(texture, X, Y, 0.05f, 0.05f)
        {
        }
        
        public void Update(GameWindow window)
        {
            // Flytta på fienden:
            ship_vector.X += ship_speed.X;
            ship_vector.Y += ship_speed.Y;
            // Kontrollera så fienden inte åker utanför fönstret på sidorna
            if (ship_vector.X > window.ClientBounds.Width - texture.Width || ship_vector.X < 0)
                ship_speed.X *= -1; // Byt riktning på fienden
            // Gör fienden inaktiv om den åker ut där nere
            if (ship_vector.Y > window.ClientBounds.Height)
                isAlive = false;
        }

        public void Update2(GameWindow window, int x, int y)
        {
            ship_vector.X = x;
            ship_vector.Y = y;   
        }
        // =======================================================================
        // Egenskaper för Enemy
        // =======================================================================
        public bool IsAlive
        {
            get { return isAlive; }
            set { isAlive = value; }
        }
    }
}