void Main()
{
	AllocationSector allocationSector = new AllocationSector();

	var sectors = new HashSet<Sector>() {
		new Sector {sector="A"},
		new Sector {sector="B"}
		
	};
	
	
	var stocks = new HashSet<Stock>() {
		new Stock {sector="A", assetValue=20, symbol="1"},
		new Stock {sector="A", assetValue=295, symbol="15"},
		new Stock {sector="A", assetValue=16, symbol="19"},
		new Stock {sector="B", assetValue=30, symbol="2"},
		new Stock {sector="B", assetValue=50, symbol="3"},
		new Stock {sector="B", assetValue=21, symbol="35"},
		new Stock {sector="B", assetValue=45, symbol="13"},
		new Stock {sector="G", assetValue=45, symbol="143"}
	};

	//cycle(sectors, stocks);
	doUsingLINQ(sectors, stocks, allocationSector);
	
	
	
}

void doUsingLINQ(HashSet<Sector> sectors,  HashSet<Stock> stocks, AllocationSector allocationSector)
{
	(from stock in stocks
	 join sector in sectors on stock.sector equals sector.sector
	 group stock by stock.sector into res
	 select new Sector { sector = res.Key, assetValue = res.Sum(_ => (int)_.assetValue) })
  .ToList().ForEach(s => allocationSector.allocations.Add(s));
  
  allocationSector.Dump();
 
}
void cycle(HashSet<Sector> sectors,  HashSet<Stock> stocks, AllocationSector allocationSector)
{
	foreach (var sector in sectors)
	{
		double sumAssetValue = 0;
		foreach (Stock stock in stocks)
		{
			if (sector.sector == stock.sector)
			{
				sumAssetValue += stock.assetValue;
			}
		}
		sector.assetValue = (int)sumAssetValue;
		allocationSector.allocations.Add(sector);
	}
	
	sectors.Dump();

}

class Sector
{
	public String sector {get; set;}
	public int assetValue {get; set;}
	public float proportion {get; set;}
	
	
}

class Stock
{
	public String symbol {get;set;}
	public int volume  {get;set;}
	public double assetValue  {get;set;}
	 public String sector  {get;set;}
}

class AllocationSector
{
	public List<Sector> allocations = new List<Sector>();
}

void Main()
{
 	var summary = BenchmarkRunner.Run<Bench>(new AllowNonOptimized());
}

public class AllowNonOptimized : ManualConfig
{
	public AllowNonOptimized()
	{
		Add(JitOptimizationsValidator.DontFailOnError); // ALLOW NON-OPTIMIZED DLLS

		Add(DefaultConfig.Instance.GetLoggers().ToArray()); // manual config has no loggers by default
		Add(DefaultConfig.Instance.GetExporters().ToArray()); // manual config has no exporters by default
		Add(DefaultConfig.Instance.GetColumnProviders().ToArray()); // manual config has no columns by default
	}
}

[RPlotExporter, RankColumn, HtmlExporter]
[SimpleJob(launchCount: 1, warmupCount: 1, targetCount: 5, invocationCount: 10, id: "QuickJob")]
public class Bench
{
	
	static Random rand = new Random();
	
	[GlobalSetup]
	public void Setup()
	{
		allocationSector = new AllocationSector();
		var sectorNames = new HashSet<String>();
		sectors = new HashSet<Sector>();
		
		for (int i=0;i<NumSectors;i++)
		{
			sectorNames.Add(RandomString(2));
		}
		
		foreach (var sectorName in sectorNames)
		{
			sectors.Add(new Sector { sector = sectorName });
		}

		stocks = new HashSet<Stock>();
		var sectorNamesList = sectorNames.ToList();
		for (int i = 0; i < NumStocks; i++)
		{
			stocks.Add(new Stock
			{
				sector = sectorNamesList[rand.Next(0, sectorNames.Count)],
				assetValue = rand.Next(10, 100),
				symbol = i.ToString()
			});
		}
	}

	public static string RandomString(int length)
	{
		const string chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789";
		return new string(Enumerable.Repeat(chars, length)
		  .Select(s => s[rand.Next(s.Length)]).ToArray());
	}

	[Params(100_000, 1_000_000)]
	public int NumStocks;

	[Params(10, 100, 1_000, 10_000)]
	public int NumSectors;

	private AllocationSector allocationSector;
	private HashSet<Stock> stocks;
	private HashSet<Sector> sectors;


	[Benchmark]
	public void performUsingLINQ()
	{
		(from stock in stocks
		 join sector in sectors on stock.sector equals sector.sector
		 group stock by stock.sector into res
		 select new Sector { sector = res.Key, assetValue = res.Sum(_ => (int)_.assetValue) })
	  .ToList().ForEach(s => allocationSector.allocations.Add(s));

	}

	[Benchmark]
	public void performUsingOneCycle()
	{
		var sectorMap = sectors.ToDictionary(t => t.sector, t => t);
		foreach (var stock in stocks)
		{
			var sector = sectorMap[stock.sector];
			if (sector.sector == stock.sector)
			{
				sector.assetValue += (int)stock.assetValue;
			}
			allocationSector.allocations.Add(sector);
		}

	}
}



public class Sector
{
	public String sector {get; set;}
	public int assetValue {get; set;}
	public float proportion {get; set;}
}

public class Stock
{
	public String symbol {get;set;}
	public int volume  {get;set;}
	public double assetValue  {get;set;}
	public String sector  {get;set;}
}

public class AllocationSector
{
	public List<Sector> allocations = new List<Sector>();
}