C#

this.game.GameStarted += delegate
           {
               this.ResetWinTransition.Begin();
               this.StatusPanel.Visibility = Visibility.Visible;
               this.TapToContinueTextBlock.Opacity = 0;
               this.TotalMovesTextBlock.Text = this.game.TotalMoves.ToString();
           };

GameStarted(null, null); 

public delegate void GameMethod();
public GameMethod GameStarted;

GameStarted();

if (this.GameStarted != null)
            {
                this.GameStarted(this, null);
            }

if (this.GameOver != null)
               {
                   this.GameOver(this, new GameOverEventArgs { TotalMoves = this.totalMoves });
               }

if (this.PieceUpdated != null)
           {
               this.PieceUpdated(this, new PieceUpdatedEventArgs {PieceId = pieceId, NewPosition = newPosition});
           }

var handler = GameStarted;
if (handler != null)
{
  handler(this, null);
}

EventHandler GameStarted = new EventHandler(GameStartedMethod);

void GameStartedMethod(object sender, EventArgs e) { ... }

EventHandler GameStarted = GameStartedMethod;

void GameStartedMethod(object sender, EventArgs e) { ... }

EventHandler GameStarted = delegate(object sender, EventArgs e) { ... }

EventHandler GameStarted = delegate { ... }

EventHandler GameStarted = (sender, e) => { ... }

Pete O'Hanlon wrote:

anonymous functions can be notoriously difficult to unregister

Pete O'Hanlon wrote:

anonymous functions can be notoriously difficult to unregister.

using Mosaic;

namespace WindowsPhonePuzzle
{
    public class PieceUpdatedEventArgs : EventArgs
    {
        public int PieceId { get; set; }
        public Point NewPosition { get; set; }
    }

    public class GameOverEventArgs : EventArgs
    {
        public int TotalMoves { get; set; }
    }

    public class PuzzleGame
    {        
                
        public EventHandler GameStarted;        
        public EventHandler<PieceUpdatedEventArgs> PieceUpdated;
        public EventHandler<GameOverEventArgs> GameOver;

        ////// More code below

                 if (this.GameStarted != null)
            {
                this.GameStarted(this, null);
            }
        }


        ////// More code below

                if (this.GameOver != null)
                {
                    this.GameOver(this, new GameOverEventArgs { TotalMoves = this.totalMoves });
                }
            }
        }

        ////// More code below


            if (this.PieceUpdated != null)
            {
                this.PieceUpdated(this, new PieceUpdatedEventArgs {PieceId = pieceId, NewPosition = newPosition});
            }
        }
    }
}

<pre lang="c#">
using WindowsPhonePuzzle;

 

namespace Mosaic
{
    public partial class PuzzlePage  : PhoneApplicationPage
    {

      
        public PuzzlePage()
        {
            InitializeComponent();
            SupportedOrientations = SupportedPageOrientation.Portrait | SupportedPageOrientation.Landscape;

            // Puzzle Game
            this.game = new PuzzleGame(3);


            this.game.GameStarted += delegate
            {
                this.ResetWinTransition.Begin();
                this.StatusPanel.Visibility = Visibility.Visible;
                this.TapToContinueTextBlock.Opacity = 0;
                this.TotalMovesTextBlock.Text = this.game.TotalMoves.ToString();
            };       

            this.game.GameOver += delegate
            {
                this.WinTransition.Begin();
                this.TapToContinueTextBlock.Opacity = 1;
                this.StatusPanel.Visibility = Visibility.Visible;
                this.TotalMovesTextBlock.Text = this.game.TotalMoves.ToString();
            };

            this.game.PieceUpdated +=  delegate(object sender, PieceUpdatedEventArgs args)
            {
                int pieceSize = ImageSize / this.game.ColsAndRows;
                this.AnimatePiece(this.puzzlePieces[args.PieceId], Canvas.LeftProperty, (int)args.NewPosition.X * pieceSize);
                this.AnimatePiece(this.puzzlePieces[args.PieceId], Canvas.TopProperty, (int)args.NewPosition.Y * pieceSize);
                this.TotalMovesTextBlock.Text = this.game.TotalMoves.ToString();
            };

            this.InitBoard();
        }

<pre lang="c#">
this.game.GameStarted += delegate

this.game.GameStarted += delegate
{
    this.ResetWinTransition.Begin();
    this.StatusPanel.Visibility = Visibility.Visible;
    this.TapToContinueTextBlock.Opacity = 0;
    this.TotalMovesTextBlock.Text = this.game.TotalMoves.ToString();
};

this.game.GameStarted += MyGameStarted;
...
private void MyGameStarted(object sender, EventArgs e)
{
    this.ResetWinTransition.Begin();
    this.StatusPanel.Visibility = Visibility.Visible;
    this.TapToContinueTextBlock.Opacity = 0;
    this.TotalMovesTextBlock.Text = this.game.TotalMoves.ToString();
};

if (this.GameStarted != null)
{
    this.GameStarted(this, null);
}

EventHandler eh = GameStarted;
if (eh != null)
{
    eh(this, null);
}

private string name;
public string Name {get { return name; } set { name = value; } }
public MyClass(string name)
   {
   this.name = name;
   }

Console.WriteLine(this.name);

Console.WriteLine(name);

public delegate void Del(string message);

// Create a method for a delegate.
public static void DelegateMethod(string message)
{
    System.Console.WriteLine(message);
}

// Instantiate the delegate.
Del handler = DelegateMethod;

// Call the delegate.
handler("Hello World");

public delegate int trivialDelegate(int int1, int int2);

public static int AddEm(int int1,int int2)
{
    return int1 + int2;
}

public static int DivEm(int int1,int int2)
{
    return int1 / int2;
}

public static trivialDelegate lateBoundAdd = AddEm;

public static trivialDelegate lateBoundDiv = DivEm;

// example of in-line anonymous method expressed in lambda form
public static trivialDelegate lateBoundSub = (int1, int2) => int1 - int2;

// somewhere in your code ... later
int addResult = lateBoundAdd(100, 200);
int divResult = lateBoundDiv(1000, 333);
int subResult = lateBoundSub(999, 666);