public static class IoC
    {  
        public static IContainer Initialize()
        {
            var container = new Container(x =>
            {

               x.For<IUnitOfWork>().HybridHttpOrThreadLocalScoped().Use(() => new baranDbContext());
                x.For<IUserService>().Use<UserService>();
                x.For<IUserMetaDataService>().Use<UserMetaDataService>();
            });

            return container;
        }
        public class StructureMapControllerFactory : DefaultControllerFactory
        {
            private readonly IContainer _container;

            public StructureMapControllerFactory(IContainer container)
            {
                _container = container;
            }
            protected override IController GetControllerInstance(RequestContext requestContext, Type controllerType)
            {
                if (controllerType == null)
                    return null;

                return (IController)_container.GetInstance(controllerType);
            }
        }
} 

var userService = ObjectFactory.GetInstance<IUserService>();

localForage is a fast and simple storage library for JavaScript.localForage uses localStorage in browsers with no IndexedDB or WebSQL.

localforage.setItem('key', 'value', function (err) {
  // if err is non-null, we got an error
  localforage.getItem('key', function (err, value) {
    // if err is non-null, we got an error. otherwise, value is the value
  });
});

:Framework Support

AngularJS

  Angular 4 and up

  Backbone

  Ember

  Vue 

TypeScript:

import localForage from "localforage"; 

export class MovieComponent {

  @Input() movie: Movie;

}

Error! Property movie has no initializer and is not assigned directly in the constructor.

@Input() movie: Movie | null = null;

class C {
    baz: boolean | undefined;
}

class C {
    bar = "hello";
}

class C {
    foo!: number;

    ngOnInit() {
        this.foo = 0;
    }
}

// Add custom user claims here
userIdentity.AddClaim(new Claim("key1", "value1"));

public static string GetClaimValue(this IPrincipal currentPrincipal, string key)
{
     var identity = currentPrincipal.Identity as ClaimsIdentity;
     if (identity == null)
          return null;

     var claim = identity.Claims.FirstOrDefault(c => c.Type == key);
     return claim?.Value;
}

ROW_NUMBER() OVER(PARTITION BY [ForeignKeyId] ORDER BY [ForeignKeyId]) [SomeSequence]

public class EntityConfigurations
    {
        internal static void LoadEntityConfigurations(Assembly[] asm, DbModelBuilder modelBuilder)
        {
            if (asm == null) throw new ArgumentNullException(nameof(asm));

            foreach (var configurations in asm.Select(assembly => assembly.GetTypes()
                    .Where(
                     type => type.BaseType != null &&
                     type.BaseType.IsGenericType &&
                     type.BaseType.GetGenericTypeDefinition() == typeof(EntityTypeConfiguration<>))
                    .ToList()))
            {
                configurations.ForEach(type =>
                {
                    dynamic instance = Activator.CreateInstance(type);
                    modelBuilder.Configurations.Add(instance);
                });
            }
        }
    }

/// <summary>
        /// 
        /// </summary>
        /// <param name="modelBuilder"></param>
        protected override void OnModelCreating(DbModelBuilder modelBuilder)
        {
            EntityConfigurations.LoadEntityConfigurations(AppDomain.CurrentDomain.GetAssemblies(), modelBuilder);
        }

@model  List<Model>