public override object Carica(XmlNode elemento)
        {
            List<Componente> componenti = new List<Componente>();
            Dictionary<string, object> vincoli = new Dictionary<string,object>();
            Dictionary<PosizioneVentola, Ventola> mappaVentole = new Dictionary<PosizioneVentola,Ventola>();

            foreach (XmlElement elementoTipo in elemento.SelectNodes("*"))
            {

                ICarica carica = CaricaFactory.GetCaricamento(elementoTipo.Name);
                if (carica != null)
                {
                    if (elementoTipo.Name == "Componenti")
                    {
                        componenti = (List<Componente>)carica.Carica(elementoTipo);
                    }
                    else if (elementoTipo.Name == "Vincoli")
                    {
                        vincoli = (Dictionary<string, object>)carica.Carica(elementoTipo);
                    }
                    else if (elementoTipo.Name == "Dissipazione")
                    {
                        mappaVentole = (Dictionary<PosizioneVentola, Ventola>)carica.Carica(elementoTipo);
                    }
                    else
                    {
                        throw new FormatException("PROBLEMA NEL FILE ASSEMBLATO: elemento non riconosciuto");
                    }
                }
            }

            Dictionary<string, List<Componente>> mappaComponenti = new Dictionary<string, List<Componente>>();

            foreach (Assembly assembly in AppDomain.CurrentDomain.GetAssemblies())
            {
                foreach (Type t in assembly.GetTypes())
                {
                    if (t.BaseType == typeof(Componente))
                        mappaComponenti.Add(t.Name, new List<Componente>());
                }
            }

            Assemblato assemblato = new Assemblato(mappaComponenti, true, vincoli);

            foreach (Componente componente in componenti)
                assemblato.AggiungiComponente(componente);

            return assemblato;
        }
            public Assemblato CalcolaConfigurazione(double budgetMassimo, bool overclock, float pesoMassimo, out string esito)
            {
                Assemblato assemblato = new Assemblato();

                esito = "";

                foreach (Assembly assembly in AppDomain.CurrentDomain.GetAssemblies())
                {
                    foreach (Type t in assembly.GetTypes())
                    {
                        if (t.BaseType == typeof(Componente))
                        {
                            //cicla su tutti i Componenti
                            /*  Alimentatore
                                Case
                                Extra                                                           
                                MemoriaRAM
                                PerifericaSATA
                                Processore
                                SchedaMadre
                                SchedaPCI
                                SchedaVideo
                                SistemaOperativo
                                Ventola
                            */

                            if (t.Name == "Extra" || t.Name == "Ventola" || t.Name == "SistemaOperativo")
                                continue;

                            
                            List<Componente> compatibili = null;
                            List<Componente> filtrati = null;
                            IFiltro ricerca = null;

                            compatibili = assemblato.SelezionaTipo(t.Name);
                            if (compatibili.Count == 0)
                            {
                                esito += "Nessun " + t.Name + " compatibile,\n";
                                continue;
                            }
                            ricerca = FiltroRicerca.GetFiltroRicerca(t.Name, compatibili);

                            Dictionary<string, object> campiRicerca = new Dictionary<string, object>();

                            double prezzo = 0D;

                            if(t.Name == "Alimentatore")
                            {
                                if (overclock)
                                    campiRicerca.Add("Potenza Erogata", 600D);
                            }
                            if(t.Name == "Processore")
                            {
                                if (overclock)
                                    campiRicerca.Add("Nome", "K");
                            }


                            // aggiunta campi di ricerca per componente
                            if (t.Name.Contains("MemoriaSecondaria"))
                            {
                                for (int p = 0; p < 2; p++)
                                {
                                    if (p == 0) //HDD
                                    {
                                        prezzo = PercentualiComponenti["MemoriaSecondaria_HDD"] * budgetMassimo;
                                        campiRicerca.Add("Tipo", TipoMemoriaSecondaria.HDD);
                                        //campiRicerca.Add("Capacità", CapacitàMemoriaSecondaria_HDD);

                                    }
                                    else if (p == 1) //SSD
                                    {
                                        prezzo = PercentualiComponenti["MemoriaSecondaria_SSD"] * budgetMassimo;
                                        campiRicerca.Add("Tipo", TipoMemoriaSecondaria.SSD);
                                        //campiRicerca.Add("Capacità", CapacitàMemoriaSecondaria_SSD);
                                    }

                                    if (prezzo == 0)
                                        continue;

                                    campiRicerca.Add("Prezzo Max", prezzo + prezzo * 0.5);
                                    campiRicerca.Add("Prezzo Min", 0D);
                                    //campiRicerca.Add("PrezzoMin", prezzo - prezzo * 0.5);

                                    filtrati = ricerca.Filtra(campiRicerca);

                                    if (filtrati.Count != 0)
                                        assemblato.AggiungiComponente(filtrati[0]);
                                    else
                                        esito += "Budget Insufficente per un " + t.Name + ",\n";

                                    campiRicerca = new Dictionary<string, object>();
                                }
                                continue;
                            }
                            else if (t.Name == "SchedaPCI")
                            {
                                //deve prendere una scheda Audio

                                prezzo = PercentualiComponenti[t.Name] * budgetMassimo;
                                campiRicerca.Add("Tipo", TipoSchedePCI.SchedaAudio);

                            }
                            else
                            {
                                prezzo = PercentualiComponenti[t.Name] * budgetMassimo;
                            }

                            if (prezzo == 0)
                                continue;

                            campiRicerca.Add("PrezzoMax", prezzo + prezzo * 0.5);
                            campiRicerca.Add("PrezzoMin", 0D);

                            filtrati = ricerca.Filtra(campiRicerca);

                            if (filtrati.Count != 0)
                            {
                                Componente best = null;
                                double differenza = double.MaxValue;

                                foreach(Componente f in filtrati)
                                {
                                    if((prezzo+prezzo*0.5)-f.Prezzo < differenza)
                                    {
                                        best = f;
                                        differenza = (prezzo + prezzo * 0.5) - f.Prezzo; 
                                    }
                                }

                                
                                assemblato.AggiungiComponente(best);
                            }
                            else
                                esito += "Budget Insufficente per un " + t.Name + ",\n";
                            //else
                              //  assemblato.AggiungiComponente(filtrati[0]);
                        }
                    }
                }


                /*
                  
                 //STAMPA VINCOLI SU FILE DI TESTO
                 
                string path = Environment.GetFolderPath(Environment.SpecialFolder.Desktop);
                StreamWriter outFile = new StreamWriter(path + @"\VincoliTipo.txt", true);

                foreach(KeyValuePair<string, object> v in assemblato.Vincoli)
                {
                    outFile.WriteLine(v.Key + " - " + v.Value);
                }
                outFile.Close();
                */

                return assemblato;
            }