private void InitStructureMap()
{
            ObjectFactory.Initialize(x =>
            {
                x.For<IUnitOfWork>().HybridHttpOrThreadLocalScoped().Use(() => new MyDbContext());
                x.For<IRequestService>().Use<RequestService>();
                x.For<IRequestTypeService>().Use<RequestTypeService>();
                x.For<IUnitService>().Use<UnitService>();
                x.For<IDomainService>().Use<DomainService>();

            });
            
            ControllerBuilder.Current.SetControllerFactory(new StructureMapControllerFactory());

            ObjectFactory.Initialize(cfg =>
            {
                cfg.For<IDependencyResolver>().Singleton().Add<StructureMapDependencyResolver>();
                // the rest ...
                cfg.For<IUnitOfWork>().HybridHttpOrThreadLocalScoped().Use(() => new MyDbContext());
                cfg.For<IRequestService>().Use<RequestService>();
                cfg.For<IRequestTypeService>().Use<RequestTypeService>();
                cfg.For<IUnitService>().Use<UnitService>();
                cfg.For<IDomainService>().Use<DomainService>();
            });
            GlobalHost.DependencyResolver = ObjectFactory.GetInstance<IDependencyResolver>();
}

    public class BloggingContext : DbContext
    {
        public BloggingContext()
        { }

        public BloggingContext(DbContextOptions options)
            : base(options)
        { }

        public DbSet<Blog> Blogs { get; set; }
        public DbSet<Post> Posts { get; set; }

        protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)
        {
            if (!optionsBuilder.IsConfigured)
            {
                optionsBuilder.EnableSensitiveDataLogging();
                optionsBuilder.UseSqlServer(@"...");
                optionsBuilder.ConfigureWarnings(warnings =>
                {
                    warnings.Log(CoreEventId.IncludeIgnoredWarning);
                    warnings.Log(RelationalEventId.QueryClientEvaluationWarning);
                });
                optionsBuilder.UseLoggerFactory(GetLoggerFactory());
            }
        }

        private ILoggerFactory GetLoggerFactory()
        {
            IServiceCollection serviceCollection = new ServiceCollection();
            serviceCollection.AddLogging(builder =>
                   builder.AddConsole()
                          //.AddFilter(category: DbLoggerCategory.Database.Command.Name, level: LogLevel.Information));
                          .AddFilter(level => true)); // log everything
            return serviceCollection.BuildServiceProvider().GetRequiredService<ILoggerFactory>();
        }
    }

using System;
using System.Collections.Generic;
using System.Data.SqlClient;
using System.IO;
using System.IO.Compression;
using System.Xml.Linq;
 
namespace EF_General
{
    public static class InsideMigrations
    {
        public static void PrintFirstMigrationModel()
        {
            const string connectionString = "Data Source=(local);Initial Catalog=TestDbIdentity;Integrated Security = true";
            const string sqlToExecute = "select top 1 model from __MigrationHistory";
 
            using (var connection = new SqlConnection(connectionString))
            {
                connection.Open();
 
                using (var command = new SqlCommand(sqlToExecute, connection))
                {
                    using (var reader = command.ExecuteReader())
                    {
                        if (!reader.HasRows)
                        {
                            throw new KeyNotFoundException("Nothing to display.");
                        }
 
                        while (reader.Read())
                        {
                            var model = (byte[]) reader["model"];
                            var decompressed = decompressMigrationModel(model);
                            Console.WriteLine(decompressed);
                        }
                    }
                }
            }
        }
 
        private static XDocument decompressMigrationModel(byte[] bytes)
        {
            using (var memoryStream = new MemoryStream(bytes))
            {
                using (var gzipStream = new GZipStream(memoryStream, CompressionMode.Decompress))
                {
                    return XDocument.Load(gzipStream);
                }
            }
        }
    }
}

 <Employees>
     <Employee>
         <Name>Vahid</Name>
         <Phone>11111111</Phone>
         <Department>IT</Department>
  <Age>52</Age>
     </Employee>
     <Employee>
         <Name>Farid</Name>
         <Phone>124578963</Phone>
         <Department>Civil</Department>
        <Age>35</Age>
     </Employee>
     <Employee>
         <Name>Mehdi</Name>
         <Phone>1245788754</Phone>
         <Department>HR</Department>
        <Age>30</Age>
     </Employee>
 </Employees>

using System.Xml.Linq;

XDocument xDoc = XDocument.Load("Employee.xml");

// loading XML from string
StringReader sr = new StringReader(stringXML);
XDocument xDoc = XDocument.Load(sr);

using System.Collections;

IEnumerable<XElement> empList = from e in xDoc.Root.Elements("Employee") select e;

foreach (XElement employee in empList)
{               
    foreach (XElement e in employee.Elements())
    {
         Console.WriteLine(e.Name + " = " + e.Value);
    }
}

IEnumerable<XElement> hrList = from e in xDoc.Root.Elements("Employee")
                                                  where e.Element("Department").Value == "HR"
                                                  select e;

IEnumerable<XElement> tList = from e in xDoc.Root.Elements("Employee")
                                                where int.Parse(e.Element("Age").Value) > 30
                                                select e;

IEnumerable<XElement> tList = from e in xDoc.Root.Elements("Employee")
                                               where int.Parse(e.Element("Age").Value) > 30
                                               orderby e.Element("Name").Value
                                               select e;

           var empList = from e in xDoc.Root.Elements("Employee")
                         orderby e.Element("Name").Value
                         select new
                         {
                             Name = e.Element("Name").Value,
                             Phone = e.Element("Phone").Value,
                             Department = e.Element("Department").Value,
                             Age = int.Parse(e.Element("Age").Value)
                         };

           foreach (var employee in empList)
           {
               Console.WriteLine("Name = " + employee.Name);
               Console.WriteLine("Dep = " + employee.Department);
               Console.WriteLine("Phone = " + employee.Phone);
               Console.WriteLine("Age = " + employee.Age);
           }

   public class Employee
   {
       public string Name { get; set; }
       public string Phone { get; set; }
       public string Department { get; set; }
       public int Age { get; set; }
  }

       public class Employee
       {
           public string Name { get; set; }
           public string Phone { get; set; }
           public string Department { get; set; }
           public int Age { get; set; }
       }

       List<Employee> Get()
       {
           XDocument xDoc = XDocument.Load("Employee.xml");
           var items =
               from e in xDoc.Root.Elements("Employee")
               orderby e.Element("Name").Value
               select new Employee
               {
                   Name = e.Element("Name").Value,
                   Phone = e.Element("Phone").Value,
                   Department = e.Element("Department").Value,
                   Age = int.Parse(e.Element("Age").Value)
               };
           return items.ToList();
       }

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace Menu.Models.Entities
{
    public class Category
    {
        public int Id { get; set; }
        public string Name { get; set; }
        public int? ParentId { get; set; }
        public virtual Category Parent { get; set; }
        public virtual ICollection<Category> Children { get; set; }
    }
}

public class MyContext : DbContext
{
        public DbSet<Category> Category { get; set; }
 
        protected override void OnModelCreating(DbModelBuilder modelBuilder)
        {
            // Self Referencing Entity
            modelBuilder.Entity<Category>()
                        .HasOptional(x => x.Parent)
                        .WithMany(x => x.Children)
                        .HasForeignKey(x => x.ParentId)
                        .WillCascadeOnDelete(false);
 
            base.OnModelCreating(modelBuilder);
        }
}