(Monogame) Update method causes extreme lag

Question

I am currently creating a 2d platformer in monogame. I created a block that, when hit by the player, starts dissapearing. When it dissapears, i draw a rectangle around it. Every Tile of the same type (BrittleTile) also starts dissapearing, untill the entire connected mob of BrittleTiles has dissapeared.

The problem is that for every BrittleTile that is destroyed, my game runs noticably slower, until it becomes a slideshow after 10 or so BrittleTiles destroyed. I have no idea as to what may cause this, i've been trying to ease the Update method of the class but nothing seems to help.

Any idea as to what may cause this?

    class BrittleTile: Tile, IIncludeSound 
{
    public Rectangle DestroyedCheckRectangle;
    private BrittleTile brittle;
    private bool _isPlayed;
    private bool _hasBroken;
    private SoundEffect _sfxBreak;
    private SoundEffectInstance _sfxiBreak;
    private TimeSpan _breakTimer = new TimeSpan();
    public Rectangle BrokenViewRectangle { get; set; }
    private bool _isBreaking = false;
    public BrittleTile(Texture2D texture, Rectangle baseViewRectangle, Rectangle brokenViewRectangle):base(texture, baseViewRectangle, true )
    {
        this.BrokenViewRectangle = brokenViewRectangle;
        this.ViewRectangle = baseViewRectangle;
    }

    public void Update(GameTime gameTime, Hero hero, Entity[,] grid)
    {
        if (!this._hasBroken)
        {
            if (!this._isBreaking && !this._hasBroken && this.hasCollision)
                _checkCollision(hero, grid);
            if (this._isBreaking)
            {
                if (!this._isPlayed)
                    _sfxiBreak.Play();
                this._isPlayed = true;
                this._breakTimer += gameTime.ElapsedGameTime;
                if (this._breakTimer.TotalMilliseconds < 250)
                    this.GhostMode(gameTime);
                else
                {
                    this._isBreaking = false;
                    this.hasCollision = false;
                    this._breakTimer -= this._breakTimer;
                }
            }
            else
            {
                if (!this.hasCollision && this.DestroyedCheckRectangle.Width == 0)
                {
                    this.DestroyedCheckRectangle.X = this.DestinationRectangle.X - 10;
                    this.DestroyedCheckRectangle.Y = this.DestinationRectangle.Y - 10;
                    this.DestroyedCheckRectangle.Height = this.DestinationRectangle.Height + 20;
                    this.DestroyedCheckRectangle.Width = this.DestinationRectangle.Width + 20;
                    this._hasBroken = true;
                }
            }
        }
    }
    public override void Draw(SpriteBatch spriteBatch)
    {
        spriteBatch.Draw(this.Texture, this.DestinationRectangle, this.BrokenViewRectangle, Color.White);
        if (this.hasCollision)
            spriteBatch.Draw(this.Texture, this.DestinationRectangle, this.ViewRectangle, Color.White * this.GhostDraw * 0.9f);
        spriteBatch.Draw(this.Texture, DestroyedCheckRectangle, new Rectangle(1, 1, 1, 1), Color.Yellow);
        Console.WriteLine(this.DestroyedCheckRectangle.X + ", " + this.DestroyedCheckRectangle.Y + ", " + this.DestroyedCheckRectangle.Width + ", " + this.DestroyedCheckRectangle.Height);
    }
    private void _checkCollision(Hero hero, Entity[,] grid)
    {
        if (this.DestinationRectangle.Intersects(hero.AttackHitBox))
        {
            this._isBreaking = true;
        }
        foreach (Shuriken star in hero.Stars)
        {
            if (this.DestinationRectangle.Intersects(star.DestinationRectangle))
                this._isBreaking = true;
        }
        foreach (Entity entityObject in grid)
        {
            if (hasCollision && entityObject.GetType() == typeof(BrittleTile)){
                brittle = entityObject.DeepCopy() as BrittleTile;
                if (this.DestinationRectangle.Intersects(brittle.DestroyedCheckRectangle))
                    this._isBreaking = true;
            }
        }
    }
    override public void LoadSounds(ContentManager content)
    {
        this._sfxBreak = content.Load<SoundEffect>("SFX/brittleBreak");
        _sfxiBreak = _sfxBreak.CreateInstance();
        _sfxiBreak.Volume = 0.2f;
    }
}

Answer 1

First, this line:

if (!this._isBreaking && !this._hasBroken && this.hasCollision)

the !this._hasBroken is superfluous.

My first warning sign is this line:

brittle = entityObject.DeepCopy() as BrittleTile;

I assume DeepCopy() makes a new version of the object, and copies all it's properties, right? Seeing the code of that might help pin it down, but on that assumption...

For every Tile, you're cycling through every object in you're grid and you're completely duplicating that object as a BrittleTile, why?

My first change would be to modify that foreach to have this within it:

var brittle = entityObject as BrittleTile
if (brittle != null && hasCollision){
    if (this.DestinationRectangle.Intersects(brittle.DestroyedCheckRectangle))
        this._isBreaking = true;
    }
}

Not sure this is the primary cause of the slowdown, but it is definitely an issue. If you're cloning an object and then immediately throwing an object away, you're almost certainly doing something wrong. If you're cloning an object and you're not editing the properties of that copy at all (and using those edits), you're definitely doing something wrong. I'd be wary before using a method like that unless you're really sure that's what you want.