Docker

Flexible: Even the most complex applications can be containerized.
  • Lightweight: Containers leverage and share the host kernel.
  • Interchangeable: You can deploy updates and upgrades on-the-fly.
  • Portable: You can build locally, deploy to the cloud, and run anywhere.
  • Scalable: You can increase and automatically distribute container replicas.
  • Stackable: You can stack services vertically and on-the-fly.
## List Docker CLI commands
docker
docker container --help

## Display Docker version and info
docker --version
docker version
docker info

## Execute Docker image
docker run hello-world

## List Docker images
docker image ls

## List Docker containers (running, all, all in quiet mode)
docker container ls
docker container ls --all
docker container ls -aq

  • docker-compose.dcproj – The file representing the project. Includes a <DockerTargetOS> element specifying the OS to be used.
  • .dockerignore – Lists the file and directory patterns to exclude when generating a build context.
  • docker-compose.yml – The base Docker Compose file used to define the collection of images built and run with docker-compose build and docker-compose run, respectively.
  • docker-compose.override.yml – An optional file, read by Docker Compose, with configuration overrides for services. Visual Studio executes docker-compose -f "docker-compose.yml" -f "docker-compose.override.yml" to merge these files.
Advertisements
Standard

12-2-2019 interview

@html.action

nonaction and child action only differences

formcollection

bind–include and exclude

variablenames

merge in sql

stored procedure with  table return paramter

 

 

Standard

micro services and docker and dotnet core

https://www.3pillarglobal.com/insights/develop-microservices-net-core-docker

 

  • Windows Forms and WPF applications are not supported. You still have to use mono to make a .NET desktop application for macOS.
  • ASP.NET WebForms don’t exist. M*icrosoft has plans to port them to ASP.NET Core either.
  • You need to create a WCF service. .NET Core does not currently support WCF. Instead, you would need to make a REST API with ASP.NET Core MVC.
  • Missing 3rd party library support. .NET Core 2.0 provides a compatibility shim between .NET Framework and .NET Core. But, you may still have issues with compatibility if the class library uses any .NET Framework APIs that are not supported. Although, this will help bridge a lot of class libraries to .NET Core.
  • Missing .NET Framework features. Some .NET Framework functionality is still missing in .NET Core. For example, Entity Framework Core is not the exact same as Entity Framework v6.
  • You need to access Windows specific APIs. If your application needs to work with the Windows Registry, WMI, or other Windows specific APIs, it won’t work with .NET Core. It is designed to be more sandboxed away from the OS.
  • Partial support for VB.NET and F#. Microsoft and the community continue to work on this but it isn’t 100% yet.
  • SignalR is not supported. It is planned for .NET Core 2.1 and is coming soon.

When Not to Run .NET Framework

There are also a few situations in which you shouldn’t run the .NET Framework, including when:

  • Multiple OS platforms are required
  • High performance and scalability are needed
  • If .NET Core works
  • Open source framework is required
Standard

directives–isolation scope

scope–>root scope,local storage

services

broad cast and emit

routing

1way binding

and 2 way binding

watchers   old value and new value

controller to view—>scope

controller to controller—>servies and factory

digest–>want js to work in angular we r using digest

 

 

Standard

Angular2

import { Component } from '@angular/core';

@Component ({
   selector: 'my-app',
   template: `<h1>Hello {{name}}</h1>`,
})
export class AppComponent  { name = 'Angular'; }

app.module.ts file.

import { NgModule }      from '@angular/core'; 
import { BrowserModule } from '@angular/platform-browser';  
import { AppComponent }  from './app.component';  

@NgModule ({ 
   imports:      [ BrowserModule ], 
   declarations: [ AppComponent ], 
   bootstrap:    [ AppComponent ] 
}) 
export class AppModule { }

 

export class AppComponent {
   appTitle: string = 'Welcome';
}
template: '
   

{{appTitle}}

To Tutorials Point
</div> '
<body>
   <my-app></my-app>
</body>
import { Component } from '@angular/core';  

@Component ({
   selector: 'my-app',
   templateUrl: 'app/app.component.html'
})

export class AppComponent {
   appTitle: string = 'Welcome';
   appStatus: boolean = true;
}
*ngFor = 'let lst of appList'>
  • {{lst.ID}}
  • {{lst.Name}}

 
Standard

cgi interview questions

data annotations at client side will be perform with the help of unobtrusive javascirpt

entity framework:

at the time of update/edit how changes will pass to database

if multiple operations are there how can we pass all of those changes to database at once other than sending multiple requests to the db to reduce performance.

dynamic object binding.

 

 

 

Standard