namespace Dal.Ef.Migrations
{
using System;
using System.Data.Entity.Migrations;
public partial class AddActiveColumnToClassesTable : DbMigration
{
public override void Up()
{
CreateTable(
"dbo.ReportParameters",
c => new
{
Id = c.Int(nullable: false, identity: true),
CenterCode = c.String(maxLength: 10),
CenterTitle = c.String(maxLength: 100),
TermCode = c.String(maxLength: 10),
TermTitle = c.String(maxLength: 100),
MasulBarnamerizi = c.String(maxLength: 100),
ModirAmuzesh = c.String(maxLength: 100),
Term_Id = c.Int(nullable: false),
Center_Id = c.Int(nullable: false),
})
.PrimaryKey(t => t.Id)
.ForeignKey("dbo.Terms", t => t.Term_Id, cascadeDelete: true)
.ForeignKey("dbo.Centers", t => t.Center_Id, cascadeDelete: true)
.Index(t => t.Term_Id)
.Index(t => t.Center_Id);
AddColumn("dbo.Classes", "IsActive", c => c.Boolean(nullable: false));
}
public override void Down()
{
DropIndex("dbo.ReportParameters", new[] { "Center_Id" });
DropIndex("dbo.ReportParameters", new[] { "Term_Id" });
DropForeignKey("dbo.ReportParameters", "Center_Id", "dbo.Centers");
DropForeignKey("dbo.ReportParameters", "Term_Id", "dbo.Terms");
DropColumn("dbo.Classes", "IsActive");
            DropTable("dbo.ReportParameters");
        }
    }
}

using System;
using System.Collections.Generic;

namespace SortedSetTest
{
   class Program
   {
       static void sample1()
       {
           var setRange = new SortedSet<int> { 2, 5, 6, 2, 1, 4, 8 };

           foreach (var i in setRange)
           {
               Console.WriteLine(i);
           }
       }

       static void Main()
       {
           sample1();
       }
   }
}

using System;
using System.Collections.Generic;

namespace SortedSetTest
{
   class Program
   {      
       static void sample2()
       {
           var setRange = new SortedSet<int>();
           var random = new Random();

           for (int counter = 0; counter < 100; counter++)
           {
               var rnd = random.Next(-180, 181);
               if (!setRange.Add(rnd))
               {
                   Console.WriteLine("Couldn't add {0}", rnd);
               }
           }

           Console.WriteLine("Result set:");
           foreach (var item in setRange)
           {
               Console.WriteLine(item);
           }
       }

       static void Main()
       {
           sample2();
       }
   }
}

using System;
using System.Collections;
using System.Collections.Generic;

namespace SortedSetTest
{
   class FileInfo
   {
       public string Name { set; get; }
       public long Size { set; get; }
   }

   class FileInfoComparer : IComparer<FileInfo>
   {
       public int Compare(FileInfo x, FileInfo y)
       {
           var caseiComp = new CaseInsensitiveComparer();
           return caseiComp.Compare(x.Name, y.Name);
       }
   }


   class Program
   {

       static void sample3()
       {
           var setRange = new SortedSet<FileInfo>(new FileInfoComparer())
                              {
                                  new FileInfo
                                      {
                                          Name = "file1.txt",
                                          Size = 100
                                      },
                                  new FileInfo
                                      {
                                          Name = "file2.txt",
                                          Size = 10
                                      },
                                      new FileInfo
                                          {
                                          Name = "file3.txt",
                                          Size = 300
                                      }
                              };

           foreach (var item in setRange)
           {
               Console.WriteLine(item.Name);
           }
       }

       static void Main()
       {
           sample3();

           Console.WriteLine("Press a key...");
           Console.ReadKey();
       }
   }
}

public static class WoObjectFactory
    {
        private static readonly Lazy<Container> ContainerBuilder =
           new Lazy<Container>(DefaultContainer, LazyThreadSafetyMode.ExecutionAndPublication);

        public static IContainer Container
        {
            get { return ContainerBuilder.Value; }
        }

        private static Container DefaultContainer()
        {
            
            var _container = new Container(x =>
            {
                var platformSpecificRegistry = PlatformAdapter.Resolve<IPlatformSpecificMapperRegistry>();
                platformSpecificRegistry.Initialize();

                x.For<ConfigurationStore>().Singleton().Use<ConfigurationStore>().Ctor<IEnumerable<IObjectMapper>>().Is(MapperRegistry.Mappers);
                x.For<IConfigurationProvider>().Use(ctx => ctx.GetInstance<ConfigurationStore>());
                x.For<IConfiguration>().Use(ctx => ctx.GetInstance<ConfigurationStore>());
                x.For<ITypeMapFactory>().Use<TypeMapFactory>();
                x.For<IMappingEngine>().Singleton().Use<MappingEngine>().SelectConstructor(() => new MappingEngine(null));

                x.For<IUnitOfWork>().HybridHttpOrThreadLocalScoped().Use(() => new WirelessOrganizationContext());

                x.Scan(scan =>
                {
                    scan.AssemblyContainingType<IDeviceService>();
                    scan.TheCallingAssembly();
                    scan.WithDefaultConventions();
                });
                x.Scan(scanner =>
                {
                    scanner.AssembliesFromApplicationBaseDirectory();

                    scanner.ConnectImplementationsToTypesClosing(typeof(ITypeConverter<,>))
                           .OnAddedPluginTypes(t => t.HybridHttpOrThreadLocalScoped());

                    scanner.ConnectImplementationsToTypesClosing(typeof(ValueResolver<,>))
                        .OnAddedPluginTypes(t => t.HybridHttpOrThreadLocalScoped());
                });

                x.Scan(scan =>
                {
                    scan.TheCallingAssembly();
                    scan.WithDefaultConventions();
                    scan.AddAllTypesOf<Profile>().NameBy(item => item.FullName);
                });

                

            });
            ConfigureAutoMapper(_container);
            return _container;
        }

        private static void ConfigureAutoMapper(IContainer container)
        {
            var configuration = container.TryGetInstance<IConfiguration>();
            if (configuration == null) return;
            //saying AutoMapper how to resolve services
            configuration.ConstructServicesUsing(container.GetInstance);
            foreach (var profile in container.GetAllInstances<Profile>())
            {
                configuration.AddProfile(profile);
            }
        }
    }

string pattern=@"[\d]+[+\- \t.,!@#$/%^&*(=);\\|<>""'\d]*[\d]+";

services.AddTransient(typeof(Lazy<>), typeof(LazyFactory<>));

class LazyFactory<T> : Lazy<T> where T : class
{
    public LazyFactory(IServiceProvider provider)
        : base(() => provider.GetRequiredService<T>())
    {
    }
}