namespace ServiceLayer.EFServices
{
    public class TABMPCREWService : ITABMPCREWService
    {
        private IUnitOfWork _uow;
        private IDbSet<TABMPCREWS> _tabmpcrews;

        public TABMPCREWService(IUnitOfWork uow)
        {
            this._uow = uow;
            _tabmpcrews = uow.Set<TABMPCREWS>();
        }

        public int Add(TABMPCREWS personnel)
        {
            int rowEffect = 0;

            _tabmpcrews.Add(personnel);
            rowEffect = _uow.SaveChanges();
            return rowEffect;
        }

    }
}

namespace ServiceLayer.Interface
{
    public interface ITABMPCREWService
    {
        int Add(TABMPCREWS personnel);
    }
}

Today we’re excited to announce our support and collaboration on a new Stage 0 proposal to bring optional and erasable type syntax to JavaScript. Because this new syntax wouldn’t change how surrounding code runs, it would effectively act as comments. We think this has the potential to make TypeScript easier and faster to use for development at every scale. We’d like to talk about why we’re pursuing this, and how this proposal works at a high level.

Let’s take a look at what’s in store for TypeScript 4.2!

• Smarter Type Alias Preservation
• Leading/Middle Rest Elements in Tuple Types
• Stricter Checks For The in Operator
• --noPropertyAccessFromIndexSignature
• abstract Construct Signatures
• The --explainFiles Flag
• Improved Uncalled Function Checks in Logical Expressions
• Destructured Variables Can Be Explicitly Marked as Unused
• Relaxed Rules Between Optional Properties and String Index Signatures
• Declare Missing Helper Function
• Breaking Changes  

In this post I’ll quickly explain the minimum you need to know in order to publish an Angular component to npm. By the end of the post you’ll know how your module to: 

• Be platform independent (i.e. run in Web Workers, Universal).
  
• Should be bundled and distributed.
  
• Work with the Angular’s Ahead-of-Time compiler.
  
• Play well with TypeScript and allow autocompletion and compile-time type checking. 
  

using CoreIocServices;
using Microsoft.AspNetCore;
using Microsoft.AspNetCore.Hosting;
using Microsoft.Extensions.DependencyInjection;

namespace CoreIocSample02
{
    public class Program
    {
        public static void Main(string[] args)
        {
            CreateWebHostBuilder(args).Build().Run();
        }

        public static IWebHostBuilder CreateWebHostBuilder(string[] args) =>
            WebHost.CreateDefaultBuilder(args)
            .ConfigureServices(serviceCollection =>
            {
                serviceCollection.AddScoped<ISomeService, SomeService>();
            })
            .UseStartup<Startup>();
    }
}

namespace CoreIocSample02
{
    public class Startup
    {
        private readonly ISomeService _someService;

        public Startup(IConfiguration configuration, ISomeService someService)
        {
            Configuration = configuration;
            _someService = someService;
        }

        public IConfiguration Configuration { get; }

a fresh re-write of the TypeScript Handbook is out of beta and is now our website’s primary resource for learning TypeScript! 

Configuring ESLint on a TypeScript project
A quick post today on how to configure ESLint to run on a TypeScript project.
 

In order to avoid bifurcating the linting tool space for TypeScript, we therefore plan to deprecate TSLint and focus our efforts instead on improving ESLint’s TypeScript support. 

This release include a set of bug fixes reported against TypeScript 2.9.1. For the complete list of fixed issues, check out the fixed issues query for TypeScript 2.9.2.