C# List.Where方法代码示例

        internal static IRepository<Contract> DummyContractsRepository()
        {
            var repo = new Mock<IRepository<Contract>>();

            var contracts = new List<Contract>();

            for (int i = 0; i < NumberOfTestObjects; i++)
            {
                contracts.Add(new Contract
                {
                    ClientId = (i % 2 == 0 ? i : 3).ToString(),
                    HitmanId = (i % 2 == 0 ? i : 3).ToString() + "hitman",
                    Deadline = DateTime.Now,
                    Status = ConnectionStatus.Pending,
                    Id = i
                });
            }

            repo.Setup(r => r.GetById(It.Is<int>(x => x == 4))).Returns(() =>
            {
                return contracts.Where(c => c.Id == 4).FirstOrDefault();
            });

            repo.Setup(r => r.All()).Returns(() =>
            {
                return contracts.AsQueryable();
            });

            return repo.Object;
        }

        public static void MergeFiles(Repository repo)
        {
            var f1 = repo.StorageWrapper.Data.MineableDataResultsDirectory + Extractor.UniqueEmailAddressesFilename;
            var f2 = repo.StorageWrapper.Data.MineableDataDirectory + Extractor.LinkedInFilename;
            var f3 = repo.StorageWrapper.Data.MineableDataDirectory + Extractor.IgnoreListFilename;

            if (!File.Exists(f1))
            {
                Console.WriteLine("Unable to locate " + f1);
                return;
            }

            if (!File.Exists(f2))
            {
                Console.WriteLine("Unable to locate " + f2);
                return;
            }

            if (!File.Exists(f3))
            {
                Console.WriteLine("Unable to locate " + f3);
                return;
            }

            var mozilla = File.ReadLines(f1).ToList();
            var linkedIn = File.ReadLines(f2).ToList();
            var ignore = File.ReadLines(f3).ToList();
            var final = new List<string>();

            foreach (var line in mozilla.Where(line => !final.Contains(line.ToLower())).Where(line => ignore.All(ignorePart => !line.ToLower().Contains(ignorePart.ToLower()))))
            {
                final.Add(line.ToLower());
            }
            foreach (var line in linkedIn.Where(line => !final.Contains(line.ToLower())).Where(line => ignore.All(ignorePart => !line.ToLower().Contains(ignorePart.ToLower()))))
            {
                final.Add(line.ToLower());
            }

            final.Sort();

            File.WriteAllLines(repo.StorageWrapper.Data.MineableDataResultsDirectory + Extractor.ConvergedEmailAddressesFilename, final);

            var domains = final.Where(x => x.Contains('@')).Select(x => x.Split('@')[1]).Distinct().ToList();

            domains.Sort();

            File.WriteAllLines(repo.StorageWrapper.Data.MineableDataResultsDirectory + Extractor.UniqueDomainsFilename, domains);

            if (UIRetriever.GetBool(String.Format("View {0}?", Extractor.ConvergedEmailAddressesFilename)))
            {
                FileVisualiser.Show(repo.StorageWrapper.Data.MineableDataResultsDirectory + Extractor.ConvergedEmailAddressesFilename);
            }

            if (UIRetriever.GetBool(String.Format("View {0}?", repo.StorageWrapper.Data.MineableDataResultsDirectory)))
            {
                DirectoryVisualiser.ShowFile(repo.StorageWrapper.Data.MineableDataResultsDirectory + Extractor.ConvergedEmailAddressesFilename);
            }
        }

        private static void AddTagsToContext(TagContext tagContext, List<Tag> tags, List<PageTag> pageTags) {
            tagContext.Tags = new Dictionary<string, Tag>();
            
            var tagsInContext = tags.Where(t => t.TagContextId == tagContext.TagContextId);

            foreach (var tag in tagsInContext) {
                var tagId = tag.TagId;
                var pages = pageTags.Where(p => p.TagId == tagId).Select(p => p.PageId);
                tag.Pages = new Collection<Guid>(pages.ToList());
                tagContext.Tags.Add(tag.TagName.ToLowerInvariant(), tag);
            }
        }

        /*
        public static List<Resumen> getResumen(edificio edificio, DateTime periodo)
        {
            try
            {
                admEntities db = Datos.getDB();
                return db.Database.SqlQuery<Resumen>
                   (
                        @"select  gg.nombre 'Grupo', tg.descripcion 'Descripcion', sum(importe) 'Importe'  from factura f
                    join tipo_gasto tg
                    on f.id_tipogasto = tg.idtipo_gasto
                    join grupo_gastos gg
                    on tg.grupo_gastos = gg.idgrupo_gastos
                    where year(f.fecha) = " + periodo.Year + @" and f.dir_edificio = '" + edificio.direccion + @"'
                    group by gg.nombre, f.id_tipogasto"
                    )
                    .ToList();
            }
            catch (Exception e)
            {
                Logger.Log.write(e.InnerException == null ? e.Message : e.InnerException.Message);
                throw e;
            }
        }
        */
        public static List<Grupo> getResumen(edificio edificio, DateTime fechaDesde, DateTime fechaHasta)
        {
            try
            {
                admEntities db = Datos.getDB();
                string query = @"select  gg.nombre Grupo, tg.descripcion Descripcion, sum(f.importe) Importe from factura f
                        join tipo_gasto tg
                        on f.id_tipogasto = tg.idtipo_gasto
                        join grupo_gastos gg
                        on tg.grupo_gastos = gg.idgrupo_gastos
                        where
                        f.fecha BETWEEN '" + getFechaForGetResumen(fechaDesde, false) + @"' AND '" + getFechaForGetResumen(fechaHasta, true) + @"'
                        and f.dir_edificio = '" + edificio.direccion + @"'
                        group by tg.idtipo_gasto";

                var resumen = db.Database.SqlQuery<Resumen>(query).OrderBy(x => x.Grupo).ToList();
                List<Grupo> grupos = new List<Grupo>();
                Grupo grupo = new Grupo();
                foreach (var r in resumen)
                {
                    Gastos gasto = new Gastos();
                    gasto.Descripcion = r.Descripcion;
                    gasto.Importe = r.Importe;

                    var g = grupos.Where(x => x.Nombre == r.Grupo).SingleOrDefault();
                    if (g == null)
                    {
                        grupo = new Grupo();
                        grupo.Nombre = r.Grupo;
                        grupo.Gastos = new List<Gastos>();
                        grupo.Gastos.Add(gasto);
                        grupos.Add(grupo);
                    }
                    else
                        grupos.Where(x => x.Nombre == r.Grupo).SingleOrDefault().Gastos.Add(gasto);
                }

                return grupos;
            }
            catch (Exception e)
            {
                Logger.Log.write(e.InnerException == null ? e.Message : e.InnerException.Message);
                throw e;
            }
        }

        public static void actualizarSectoresEdificioWeb(edificio edificio, List<sector> sectoresNuevos)
        {
            try
            {
                admEntities db = Datos.getDB();
                var ESActuales = db.edificios_sectores.Where(x => x.dir_edificio == edificio.direccion).ToList();
                var ed = db.edificio.Where(x => x.direccion == edificio.direccion).SingleOrDefault();
                var allSectores = db.sector.ToList();

                List<edificios_sectores> ESaBorrar = new List<edificios_sectores>();
                List<sector> SectoresAAgregar = new List<sector>();

                foreach (var s in sectoresNuevos)
                    if (ESActuales.Where(x => x.sector.descripcion == s.descripcion).SingleOrDefault() == null)
                        SectoresAAgregar.Add(s);

                foreach (var es in ESActuales)
                    if (sectoresNuevos.Where(x => x.descripcion == es.sector.descripcion).SingleOrDefault() == null)
                        db.edificios_sectores.Remove(es);

                foreach(var s in SectoresAAgregar)
                {
                    edificios_sectores es = new edificios_sectores();
                    es.dir_edificio = ed.direccion;
                    es.id_sector = s.idsector;
                    es.sector = db.sector.Where(x => x.descripcion == s.descripcion).SingleOrDefault();
                    db.edificios_sectores.Add(es);
                }

                db.SaveChanges();
            }
            catch (Exception e)
            {
                string str = e.InnerException == null ? e.Message : e.InnerException.Message;
                Logger.Log.write(str);
                throw e;
            }
        }

 private static List<Sector> OrdenarSectores(List<Sector> sectores, List<sector> sectoresDB)
 {
     List<Sector> tmp = new List<Sector>();
     foreach(var s in sectoresDB)
     {
         var tmpSector = sectores.Where(x => x.Nombre == s.descripcion).SingleOrDefault();
         if (tmpSector != null)
             tmp.Add(tmpSector);
     }
     return tmp;
 }

        public static ResumenFinal getResumenFinal(edificio e, DateTime fechaDesde, DateTime fechaHasta)
        {
            try
            {
                admEntities db = Datos.getDB();
                ResumenFinal resumenFinal = new ResumenFinal();
                fechaHasta = DateTime.Parse(fechaHasta.AddMonths(1).AddDays(-fechaHasta.Day).Day + "/" + fechaHasta.Month + "/" + fechaHasta.Year);

                var sectoresDB = db.sector.ToList();

                var facturas = db.factura.Where(x => x.dir_edificio == e.direccion && x.fecha >= fechaDesde && x.fecha <= fechaHasta).ToList();

                //var facturasAgrupadas = facturas.GroupBy(x => x.fecha.ToString("MM yyyy")).Select(x=> new { Importe = x.Sum(y=> y.importe) });

                DateTime tmpFecha = fechaDesde;
                List<Periodo> periodos = new List<Periodo>();
                bool seguir = true;

                do
                {
                    List<Sector> sectores = new List<Sector>();
                    var Conceptos = db.Database.SqlQuery<Conceptos>(@"select  s.descripcion 'Sector', f.numero_factura 'NumeroFactura', p.razon_social 'Proveedor', concat(tg.descripcion, ' ', f.detalle) 'concepto', f.importe from factura f                                                     left join provedor p                            on p.razon_social = f.razon_provedor   join sector s on id_sector = s.idsector      join tipo_gasto tg  on f.id_tipogasto = tg.idtipo_gasto                    where dir_edificio = '" + e.direccion + "' and month(f.fecha) = " + tmpFecha.Month + " and year(f.fecha) = " + tmpFecha.Year).ToList();
                    foreach(var c in Conceptos.OrderBy(x=> x.Sector))
                    {
                        var s = sectores.Where(x => x.Nombre == c.Sector).SingleOrDefault();
                        if (s == null)
                        {
                            Sector sect = new Sector();
                            sect.Nombre = c.Sector;
                            sect.Importe += c.Importe;
                            sectores.Add(sect);
                        }
                        else
                            s.Importe += c.Importe;
                    }

                    sectores = OrdenarSectores(sectores,sectoresDB);

                    Periodo p = new Periodo();
                    p.Sectores = sectores;
                    p.Total = sectores.Sum(x => x.Importe);
                    p.Nombre = tmpFecha.Month + "/" + tmpFecha.Year;

                    if (sectores.Count > 0)
                        periodos.Add(p);

                    if (tmpFecha <= fechaHasta)
                        seguir = true;
                    else
                        seguir = false;

                    tmpFecha = tmpFecha.AddMonths(1);
                }
                while (seguir);

                resumenFinal.Periodos = periodos;

                var deudaDelEdificio = CatalogoDeudores.getDeudoresFromEdificioRegenerarUnidad(e, fechaHasta).Sum(x=> x.Importe);
                var totalExpensas = periodos.Sum(x => x.Total);

                var entradasDeCaja = getMovimientosCaja(e, fechaDesde, fechaHasta).Sum(x => x.importe > 0 ? (Double)x.importe : 0);

                var salidasDeCaja = getMovimientosCaja(e, fechaDesde, fechaHasta).Sum(x => x.importe < 0 ? (Double)x.importe : 0);

                if (salidasDeCaja < 0)
                    salidasDeCaja *= -1;

                resumenFinal.CobroDeExpensas = totalExpensas - deudaDelEdificio;
                resumenFinal.CobroFondosEspeciales = entradasDeCaja;
                resumenFinal.TotalIngresos = totalExpensas - deudaDelEdificio + entradasDeCaja;

                resumenFinal.GastosComunes = totalExpensas;
                resumenFinal.GastosEspeciales = salidasDeCaja;
                resumenFinal.TotalEgresos = totalExpensas + salidasDeCaja;

                resumenFinal.SaldoEnCaja = resumenFinal.TotalIngresos - resumenFinal.TotalEgresos;

                return resumenFinal;

            }
            catch (Exception ex)
            {
                Logger.Log.write(ex.InnerException == null ? ex.Message : ex.InnerException.Message);
                throw ex;
            }
        }

        public static List<CatalogoExpensas.Pagos> registrarPagosAutomaticos(DateTime periodo, List<Pagos> pagos)
        {
            try
            {
                admEntities db = new admEntities();

                //Si alguien paga por automatico, queda totalmente al dia. Sumar recargos cobrados de meses anteriores o si pago en 2 vto
                List<expensas> expensas = new List<expensas>();
                List<Recargo> gastosExclusivos = new List<Recargo>();
                List<recargos> recargos = new List<recargos>();

                foreach (var p in pagos)
                {
                    var exp = db.expensas.Where(x => x.nro_referencia == p.nroReferencia).OrderByDescending(x => x.fecha).First();
                    var uni = new unidad();
                    uni.dir_edificio = exp.dir_edificio;
                    uni.id_unidad = exp.id_unidad;
                    p.Edificio = uni.dir_edificio;
                    p.Unidad = uni.id_unidad;
                    p.Periodo = exp.fecha.Month + "/" + exp.fecha.Year;

                    var expensasMismaUnidad = db.expensas.Where(x => x.dir_edificio == uni.dir_edificio && x.id_unidad == uni.id_unidad && x.pagado == 0).ToList();
                    var exclusivosMismaUnidad = CatalogoGastosExclusivos.getAllRecargos(uni);

                    expensas.AddRange(expensasMismaUnidad);
                    gastosExclusivos.AddRange(exclusivosMismaUnidad);
                }

                var expGrouped = expensas.GroupBy(x => new { x.dir_edificio, x.id_unidad })
                                        .Select(x => new expensas { dir_edificio = x.Key.dir_edificio, id_unidad = x.Key.id_unidad })
                                        .Cast<expensas>()
                                        .ToList();

                foreach (expensas e in expensas)
                {
                    e.pagado = 1;
                    db.Entry(e).State = System.Data.EntityState.Modified;
                }

                foreach (expensas e in expGrouped)
                {
                    recargos r = new recargos();
                    var uni = new unidad();
                    uni.dir_edificio = e.dir_edificio;
                    uni.id_unidad = e.id_unidad;
                    r.dir_edificio = e.dir_edificio;
                    r.periodo = DateTime.Parse("1/" + DateTime.Now.Month + "/" + DateTime.Now.Year);
                    var detalles = CatalogoDeudores.getDetalleDeudaUnidad(uni);
                    r.importe = detalles.Sum(x => x.Recargo);

                    var rExistente = recargos.Where(x => x.dir_edificio == r.dir_edificio && x.periodo == r.periodo).SingleOrDefault();

                    if (rExistente != null)
                        rExistente.importe += r.importe;
                    else
                        recargos.Add(r);
                }

                db.SaveChanges();

                foreach (var excl in gastosExclusivos)
                {
                    switch (excl.Tipo)
                    {
                        case "Exclusivos":
                            CatalogoGastosExclusivos.pagarRecargoExclusivo(excl.Edificio, excl.Unidad, excl.Concepto, excl.Fecha);
                            break;
                        case "Legales":
                            CatalogoGastosExclusivos.pagarRecargoLegales(excl.Edificio, excl.Unidad, excl.Concepto, excl.Fecha);
                            break;
                        case "Varios":
                            CatalogoGastosExclusivos.pagarRecargoVarios(excl.Edificio, excl.Unidad, excl.Concepto, excl.Fecha);
                            break;
                    }
                }

                CatalogoRecargos.addRecargos(recargos);

                return pagos;

            }
            catch (Exception e)
            {
                Logger.Log.write(e.InnerException == null ? e.Message : e.InnerException.Message);
                var str = "";
                str = e.InnerException?.InnerException?.Message;
                Logger.Log.write("Otro error: " + str);
                throw e;
            }
        }

        public static ExpensasEdificio getExpensasEdificio(edificio edificio, DateTime periodo, DateTime vto1, DateTime vto2, ref int correlativo, admEntities db, List<expensas> allExpensasExistentes)
        {
            try
            {
                ExpensasEdificio expensasEdificio = new ExpensasEdificio();
                {

                    expensasEdificio.Periodo = periodo;
                    expensasEdificio.Edificio = edificio;//db.edificio.Where(x => x.direccion == edificio.direccion).SingleOrDefault();
                    List<unidad> unidades = CatalogoUnidades.getAllUnidades(edificio);
                    // expensasEdificio.Sectores = (from es in db.edificios_sectores join e in db.edificio on es.dir_edificio equals e.direccion join s in db.sector on es.id_sector equals s.idsector where e.direccion == edificio.direccion select s).ToList();
                    expensasEdificio.Conceptos = db.Database.SqlQuery<Conceptos>(@"select  s.descripcion 'Sector', f.numero_factura 'NumeroFactura', p.razon_social 'Proveedor', concat(tg.descripcion, ' ', f.detalle) 'concepto', f.importe from factura f                                                     left join provedor p                            on p.razon_social = f.razon_provedor   join sector s on id_sector = s.idsector      join tipo_gasto tg  on f.id_tipogasto = tg.idtipo_gasto                    where dir_edificio = '" + edificio.direccion + "' and month(f.fecha) = " + periodo.Month + " and year(f.fecha) = " + periodo.Year).ToList();
                    expensasEdificio.TotalUnidad = new List<TotalUnidad>();
                    expensasEdificio.EstadoDeCaja = new EstadoCaja();
                    expensasEdificio.EstadoDeCaja.MovimientosDeCaja = db.Database.SqlQuery<MovimientosCaja>("select * from movimiento_caja mc where dir_edificio = '" + edificio.direccion + @"' and month(periodo)=" + periodo.Month + " and year(periodo)=" + periodo.Year).ToList();

                    List<provedor> proveedores = db.edificio.Where(x => x.direccion == edificio.direccion).SingleOrDefault().provedor.ToList();
                    expensasEdificio.Proveedores = new List<Proveedor>();
                    foreach (var pr in proveedores)
                    {
                        Proveedor prov = new Proveedor();
                        prov.cargo = pr.cargo;
                        prov.nombre = pr.razon_social;
                        prov.telefono = pr.telefono1;
                        expensasEdificio.Proveedores.Add(prov);
                    }

                    DateTime fechaActual = DateTime.Parse(1 + "/" + periodo.Month + "/" + periodo.Year);
                    DateTime fechaAnterior = fechaActual.AddMonths(-1);
                    expensasEdificio.EstadoDeCaja.FechaActual = fechaActual.ToShortDateString();
                    expensasEdificio.EstadoDeCaja.FechaAnterior = fechaAnterior.ToShortDateString();
                    expensasEdificio.Deudores = CatalogoDeudores.getDeudoresFromEdificio(edificio, periodo);
                    int tasaRecargoVto = CatalogoTasas.getTasaVto();
                    expensasEdificio.Tasa2Vto = tasaRecargoVto;

                    Double saldoCajaMesAnterior = CatalogoCajaEdificio.getSaldoCajaMes(edificio, fechaAnterior.AddMonths(1).AddDays(-1));
                    Double saldoCajaMesActual = CatalogoCajaEdificio.getSaldoCajaMes(edificio, fechaActual.AddMonths(1).AddDays(-1));

                    expensasEdificio.EstadoDeCaja.ImporteAnterior = saldoCajaMesAnterior;
                    expensasEdificio.EstadoDeCaja.ImporteActual = saldoCajaMesActual;

                    DateTime asd = DateTime.Parse("1 /" + periodo.Month + "/" + periodo.Year);

                    List<expensas> expensasExistentes = allExpensasExistentes.Where(x => x.dir_edificio == edificio.direccion).ToList();

                    foreach (unidad u in unidades)
                    {
                        unidad tempUni = new unidad();
                        if (u.titular == null)
                        {
                            tempUni.titular = new titular();
                            tempUni.titular.nombre = "<<ninguno>>";
                        }
                        else
                            tempUni.titular = u.titular;

                        TotalUnidad totalUnidad = new TotalUnidad();
                        totalUnidad.Unidad = tempUni;
                        string idUnidad = u.id_unidad;
                        tempUni.id_unidad = idUnidad;

                        totalUnidad.Exclusivos = db.recargo_exclusivo.Where(x => x.dir_edificio == u.dir_edificio && x.id_unidad == u.id_unidad && x.fecha.Month == periodo.Month && x.fecha.Year == periodo.Year && x.pagado != 1).Sum(x => (double?)x.importe) ?? 0; ;
                        totalUnidad.Legales = db.recargo_legal.Where(x => x.dir_edificio == u.dir_edificio && x.id_unidad == u.id_unidad && x.fecha.Month == periodo.Month && x.fecha.Year == periodo.Year && x.pagado != 1).Sum(x => (double?)x.importe) ?? 0; ;
                        totalUnidad.Varios = db.recargo_vario.Where(x => x.dir_edificio == u.dir_edificio && x.id_unidad == u.id_unidad && x.fecha.Month == periodo.Month && x.fecha.Year == periodo.Year && x.pagado != 1).Sum(x => (double?)x.importe) ?? 0; ;

                        totalUnidad.TotalSector = db.Database.SqlQuery<Totales>(@"DROP TEMPORARY TABLE IF EXISTS asd;                        CREATE TEMPORARY TABLE IF NOT EXISTS asd AS (                        select id_sector,porcentaje from unidades_sectores us                        where us.dir_edificio = '" + edificio.direccion + @"' and us.id_unidad = '" + u.id_unidad + @"');                        SELECT descripcion 'sector', sum(importe)'importe', porcentaje 'distribucion', (sum(importe) / 100 * porcentaje) 'corresponde' FROM factura f                        join sector s                        on s.idsector = f.id_sector                        join asd r1                        on r1.id_sector = s.idsector                        where month(f.fecha) = " + periodo.Month + @" and year(f.fecha) = " + periodo.Year + @" and f.dir_edificio = '" + edificio.direccion + @"'                        group by  descripcion                        order by r1.id_sector                        ").ToList();

                        double deuda = 0;
                        double recargo = 0;

                        foreach (CatalogoDeudores.Deudor d in expensasEdificio.Deudores)
                        {
                            if (u.id_unidad == d.Unidad)
                            {
                                deuda += d.Importe;
                                recargo += d.Recargo;
                            }
                        }
                        totalUnidad.Deuda = deuda;
                        totalUnidad.Recargo = recargo;
                        totalUnidad.NroFactura = (correlativo++).ToString();
                        expensasEdificio.TotalUnidad.Add(totalUnidad);

                        double importe1 = 0;
                        double importe2 = 0;
                        double mesEnEmision = 0;
                        foreach (Totales total in totalUnidad.TotalSector) //CatalogoExpensas.getTotales(edificio, unidad, periodo))
                        {
                            mesEnEmision += total.corresponde;
                        }

                        importe1 = mesEnEmision + totalUnidad.Deuda + totalUnidad.Recargo;
                        Double importeSinExclusivos = importe1;

                        importe1 += totalUnidad.Exclusivos;
                        importe1 += totalUnidad.Varios;
                        importe1 += totalUnidad.Legales;

                        importe2 = importe1 * (1 + (Double)tasaRecargoVto / 100);

//.........这里部分代码省略.........

 public Table Map(Func<Value[],Value[]> mapFunction)
 {
     List<Value[]> rows = new List<Value[]>();
       for (int i = 0; i < Rows.Count; i++)
       {
     rows.Add(mapFunction(Rows[i]));
       }
       rows = rows.Where(r => !r.Any(v => v.IsEmpty())).ToList();
       return new Table(rows);
 }

        public async void OnUpdate(EventArgs args)
        {
            if (processing || sleeper.Sleeping || !Game.IsInGame)
            {
                return;
            }

            processing = true;

            foreach (var unit in
                ObjectManager.GetEntitiesParallel<Unit>()
                    .Where(
                        x =>
                            !(x is Building) && x.IsValid && x.IsAlive && x.IsSpawned
                            && (!x.IsIllusion
                                || x.HasModifiers(
                                    new[]
                                    {
                                        "modifier_arc_warden_tempest_double",
                                        "modifier_vengefulspirit_hybrid_special",
                                        "modifier_morph_hybrid_special"
                                    },
                                    false))))
            {
                var abilities = new List<Ability>();

                try
                {
                    abilities.AddRange(unit.Spellbook.Spells.ToList());

                    if (unit.HasInventory)
                    {
                        abilities.AddRange(unit.Inventory.Items);
                    }
                }
                catch (Exception)
                {
                }

                foreach (var ability in
                    abilities.Where(x => x.IsValid && !addedAbilities.Contains(x.Handle) && x.Level > 0))
                {
                    if (unit.Equals(Hero))
                    {
                        var abilityName = ability.Name;

                        Func<Ability, UsableAbility> func;
                        if (allyAbilitiesData.CounterAbilities.TryGetValue(abilityName, out func))
                        {
                            Menu.UsableAbilities.AddAbility(abilityName, AbilityType.Counter);
                            UsableAbilities.Add(func.Invoke(ability));
                        }
                        if (allyAbilitiesData.DisableAbilities.TryGetValue(abilityName, out func))
                        {
                            Menu.UsableAbilities.AddAbility(abilityName, AbilityType.Disable);
                            UsableAbilities.Add(func.Invoke(ability));
                        }
                        if (allyAbilitiesData.BlinkAbilities.TryGetValue(abilityName, out func))
                        {
                            Menu.UsableAbilities.AddAbility(abilityName, AbilityType.Blink);
                            UsableAbilities.Add(func.Invoke(ability));
                        }
                    }
                    else if (unit.Team != HeroTeam || ability.ClassID == ClassID.CDOTA_Ability_FacelessVoid_Chronosphere)
                    {
                        Func<Ability, EvadableAbility> func;
                        if (enemyAbilitiesData.EvadableAbilities.TryGetValue(ability.Name, out func))
                        {
                            var evadableAbility = func.Invoke(ability);
                            await Menu.EnemiesSettings.AddAbility(evadableAbility);
                            EvadableAbilities.Add(evadableAbility);
                        }
                    }

                    addedAbilities.Add(ability.Handle);
                }
            }

            sleeper.Sleep(3000);
            processing = false;
        }

 public string GetMyComments() {
     if (Data.TheUserWhichHasCurrentlyLoggedIntoTheIssueTrackingSystem == null)
         return string.Format("There is no currently logged in user");
     var comments = new List<Kommentar>();
     Data.issues1.Select(i => i.Value.Comments).ToList()
         .ForEach(item => comments.AddRange(item));
     var resultComments = comments
         .Where(c => c.Author.Benutzer_name == Data.TheUserWhichHasCurrentlyLoggedIntoTheIssueTrackingSystem.Benutzer_name)
         .ToList();
     var strings = resultComments
         .Select(x => x.ToString());
     if (!strings.Any()) return "No comments";
     return string.Join(Environment.NewLine, strings);
 }

        public static void ImportData(string directory)
        {
            var db = new CarsDbContext();
            db.Configuration.ValidateOnSaveEnabled = false;
            db.Configuration.AutoDetectChangesEnabled = false;

            using (StreamReader reader = new StreamReader(directory))
            {
                var json = reader.ReadToEnd();
                //Console.WriteLine(json);

                var cars = JsonConvert.DeserializeObject<List<CarJson>>(json);

                //StringComparer.OrdinalIgnoreCase in constructor
                //new HashSet<string>
                var dealers = new List<DealerJson>();
                var cities = new HashSet<string>();
                var manufacturers = new HashSet<string>();

                foreach (var car in cars)
                {
                    cities.Add(car.Dealer.City);
                    dealers.Add(car.Dealer);
                    manufacturers.Add(car.Manufacturer);
                }

                foreach (var city in cities)
                {
                    // with 1 dealer in two towns it will make two of the same dealers
                    db.Cities.AddOrUpdate(new City
                    {
                        Name = city,
                        Dealers = dealers.Where(d => d.City == city).Select(d => new Dealer
                        {
                            Name = d.Name
                        }).ToList()
                    });
                }

                db.SaveChanges();

                foreach (var manufacturer in manufacturers)
                {
                    db.Manufacturers.AddOrUpdate(new Manufacturer
                    {
                        Name = manufacturer
                    });
                }

                db.SaveChanges();

                for (var car = 0; car < cars.Count; car++)
                {
                    // slow ?
                    var currentCarDealersName = cars[car].Dealer.Name;
                    var currentDealer = db.Dealers.Where(d => d.Name == currentCarDealersName).First();

                    var currentCarManufacturersName = cars[car].Manufacturer;
                    var currentManufacturer = db.Manufacturers.Where(m => m.Name == currentCarManufacturersName).First();

                    db.Cars.AddOrUpdate(new Car
                    {
                        Year = cars[car].Year,
                        Transmission = cars[car].TransmissionType,
                        Model = cars[car].Model,
                        Price = cars[car].Price,
                        Manufacturer = currentManufacturer,
                        Dealer = currentDealer
                    });

                    if (car % 100 == 0)
                    {
                        db.SaveChanges();
                        db.Dispose();
                        db = new CarsDbContext();
                    }

                    db.SaveChanges();

                    db.Configuration.ValidateOnSaveEnabled = true;
                    db.Configuration.AutoDetectChangesEnabled = true;
                }
            }
        }

 private static void ExecutePostStartupSequence(List<IStartupSequence> sequences) {
     foreach (var startupSequence in sequences.Where(s => s.StartupOrder >= 0).OrderBy(s => s.StartupOrder)) {
         startupSequence.Startup();
     }
 }

        private static List<station> FilterStationsBy(int varid, bool isPublic, List<station> stations, List<stationsvariable> vars)
        {
            List<short> filtered;
            IEnumerable<stationsvariable> filteredvars = vars;

            if (isPublic)
                filteredvars = filteredvars.Where(x => x.is_public == true);
            if (varid != 0)
                filteredvars = filteredvars.Where(x => x.var_id == varid);

            filtered = filteredvars.GroupBy(x => x.st_id).Select(x => x.Key).ToList();

            return stations.Where(x => filtered.Contains(x.st_id)).ToList();
        }