Flyweight pattern in this simple net core Api uses more memory ram

I'm trying to aplicate Flyweight method pattern in a simple .net core Api to see how much memory is saved compared to not using the pattern.

I have two methods, the first one creates 5000 objects without uses the pattern and the another creates 5000 object using the pattern. After each of them create the objects, then they call a method that returns the current memory used by the App.

public class MemoryService : IMemoryService
{
    private readonly TreeFactory _treeFactory;
    public MemoryService()
    {
        _treeFactory = new TreeFactory();
    }

    //create without pattern
    public long SetObjectsMemory()
    {
        List<Tree> trees = new List<Tree>();
        for (int i = 0; i < 5000; i++)
        {
            var tree = new Tree()
            {
                Id = new Random().Next(1, 9999999),
                Part = new PartTree()
                {
                    Name = "Nameany",
                    Bark = "Barkany",
                    Color = "Colorany"
                }
            };
            trees.Add(tree);
        };

        return Utilities.GetCurrentMemoryUsed();
    }

    //crete with flyweight pattern
    public long SetObjectsMemoryFactory()
    {
        List<Tree> trees = new List<Tree>();
        for (int i = 0; i < 5000; i++)
        {
            var tree = new Tree()
            {
                Id = new Random().Next(1, 9999999),
                Part = _treeFactory.GetPartTree("Nameany", "Barkany", "Colorany")
            };
            trees.Add(tree);
        }

        return Utilities.GetCurrentMemoryUsed();
    }
}

I use the pattern like a class that uses a list of Parts and return a part object if exists.

public class TreeFactory
{
    private static List<PartTree> _parts;

    public TreeFactory() {
        _parts = new List<PartTree>();
    }
    public PartTree GetPartTree(string name, string bark, string color)
    {
        if (_parts.Any(x => x.Name == name && x.Bark == bark && x.Color == color))
        {
            return _parts.Where(x => x.Name == name && x.Bark == bark && x.Color == color).FirstOrDefault();
        }
        else {
            var newpart = new PartTree()
            {
                Name = name,
                Bark = bark,
                Color = color
            };
            _parts.Add(newpart);
            return newpart;
        }
        
    }
}

The way to get the current memory used by the App is using Process of this way (in Utilities class):

public static long GetCurrentMemoryUsed() {
        Int64 memory;
        using (Process proc = Process.GetCurrentProcess())
        {
            memory = proc.PrivateMemorySize64 / (1024 * 1024);
        }

        return memory;
    }

And in my Startup i inject the MemoryService like a Singleton. In the controller i use 3 methods for call the functions:

 [HttpGet, Route(nameof(WeatherForecastController.GenerateMemory))]
    public IActionResult GenerateMemory()
    {
        var total=_memoryService.SetObjectsMemory();
        return Ok(total);
    }

    [HttpGet, Route(nameof(WeatherForecastController.GenerateLiftMemory))]
    public IActionResult GenerateLiftMemory()
    {
        var total = _memoryService.SetObjectsMemoryFactory();
        return Ok(total);
    }

    [HttpGet, Route(nameof(WeatherForecastController.GetMemory))]
    public IActionResult GetMemory()
    {
        var total = Utilities.GetCurrentMemoryUsed();
        return Ok(total);
    }

The problem is: When i call in the navigator the method in controller without pattern (/weatherforecast/GenerateMemory), then this returns (current)+2mb, but when i call the method with pattern (/weatherforecast/GenerateLiftMemory) this returns (current)+3mb.

Why the method with pattern flyweight returns more used MB (growing) than the methods without the pattern ??

The repository with the code for test it. Gitlab repository memory api

The code which uses TreeFactory consumes more memory because its GetPartTree method called many times in a loop so as Linq methods Any and Where inside it. Both of these methods create additional Iterator objects under the hood in order to iterate through the collection and it causes additional memory consumption.

I wrote simple benchmark using BenchmarkDotNet with more options to demonstrate the issue

Extended MemoryService

public class MemoryService : IMemoryService
{
    private const int TreeCount = 50000;
    private readonly TreeFactory _treeFactory;
    public MemoryService()
    {
        _treeFactory = new TreeFactory();
    }

    //crea objetos en memoria sin patrones
    public decimal SetObjectsMemory()
    {
        List<Tree> trees = new List<Tree>();
        for (int i = 0; i < TreeCount; i++)
        {
            var tree = new Tree()
            {
                Id = 1,
                Part = new PartTree()
                {
                    Name = "Nameany",
                    Bark = "Barkany",
                    Color = "Colorany"
                }
            };
            trees.Add(tree);
        };

        return Utilities.GetCurrentMemoryUsed();
    }

    //crea objetos en memoria usando patron flyweight
    public decimal SetObjectsMemoryFactory()
    {
        List<Tree> trees = new List<Tree>();
        for (int i = 0; i < TreeCount; i++)
        {
            var tree = new Tree()
            {
                Id = 1,
                Part = _treeFactory.GetPartTree("Nameany", "Barkany", "Colorany")
            };
            trees.Add(tree);
        }

        return Utilities.GetCurrentMemoryUsed();
    }

    public decimal SetObjectsMemoryFactoryImproved()
    {
        List<Tree> trees = new List<Tree>();
        for (int i = 0; i < TreeCount; i++)
        {
            var tree = new Tree()
            {
                Id = 1,
                Part = _treeFactory.GetPartTreeImproved("Nameany", "Barkany", "Colorany")
            };
            trees.Add(tree);
        }

        return Utilities.GetCurrentMemoryUsed();
    }

    //crea objetos en memoria usando patron flyweight
    public decimal SetObjectsMemoryFactoryWithoutLambda()
    {
        List<Tree> trees = new List<Tree>();
        for (int i = 0; i < TreeCount; i++)
        {
            var tree = new Tree()
            {
                Id = 1,
                Part = _treeFactory.GetPartTreeWithoutLambda("Nameany", "Barkany", "Colorany")
            };
            trees.Add(tree);
        }

        return Utilities.GetCurrentMemoryUsed();
    }
}

Extended TreeFactory

public class TreeFactory
{
    private static List<PartTree> _parts;

    public TreeFactory()
    {
        _parts = new List<PartTree>();
    }

    public PartTree GetPartTree(string name, string bark, string color)
    {
        if (_parts.Any(x => x.Name == name && x.Bark == bark && x.Color == color))
        {
            return _parts.Where(x => x.Name == name && x.Bark == bark && x.Color == color).FirstOrDefault();
        }

        var newpart = new PartTree()
        {
            Name = name,
            Bark = bark,
            Color = color
        };
        _parts.Add(newpart);
        return newpart;
    }

    public PartTree GetPartTreeImproved(string name, string bark, string color)
    {
        var existingPart = _parts.Where(x => x.Name == name && x.Bark == bark && x.Color == color).FirstOrDefault();
        if (existingPart != null)
            return existingPart;

        var newpart = new PartTree()
        {
            Name = name,
            Bark = bark,
            Color = color
        };
        _parts.Add(newpart);
        return newpart;

    }

    public PartTree GetPartTreeWithoutLambda(string name, string bark, string color)
    {
        for (int i = 0; i < _parts.Count; i++)
        {
            var x = _parts[i];
            if (x.Name == name && x.Bark == bark && x.Color == color)
                return x;
        }

        var newpart = new PartTree()
        {
            Name = name,
            Bark = bark,
            Color = color
        };
        _parts.Add(newpart);
        return newpart;

    }
}

Benchmark in a separate console project

class Program
{
    static void Main(string[] args)
    {
        var result = BenchmarkRunner.Run<MemoryBenchmark>();
    }
}


[MemoryDiagnoser]
public class MemoryBenchmark
{
    private IMemoryService memoryService;

    [GlobalSetup]
    public void Setup()
    {
        memoryService = new MemoryService();
    }

    [Benchmark]
    public object SimpleTrees()
    {
        var trees = memoryService.SetObjectsMemory();
        return trees;
    }

    [Benchmark]
    public object FlyTrees()
    {
        var trees = memoryService.SetObjectsMemoryFactory();
        return trees;
    }

    [Benchmark]
    public object FlyTreesImproved()
    {
        var trees = memoryService.SetObjectsMemoryFactoryImproved();
        return trees;
    }

    [Benchmark]
    public object FlyTreesWithoutLambda()
    {
        var trees = memoryService.SetObjectsMemoryFactoryWithoutLambda();
        return trees;
    }
}

And its results