Dynamic keyword
1.Dynamic keyword can be assigned to any value
dynamic t="hello"
t=false;
t=new list<int>();
2.It can take the identity of any type on the fly
3.

Process,Domain,context,clr

1. its an os level concept used to describe set of resources and necessary memory allocation used by application
2. every executable function will have primary thread and primary thread can spawn multiple secondary threads
3. .net executable are hosted by logical partition within a process called app domain
4. each process may contain multiple app domains
5. app domain are far less expensive in terms of processing power and memory than full blown process
6. app domain improves scalability of server applications
7. app domain provides deeper level isolation and failing of one app domain will not impact other app domain
8. one app domain cant use other app domain data unless its using distributed programming protocol such as wcf
9. adding assemly to custom domain
   appdomain ad=appdomain.createdomain("seconddoamin");
   ad.load("carlibrary") | car library is the assembly
10. single appdomain can contain multiple contextual bounderies
11. contextual boundaries can be synchronize or a synchronize
12. CIL is the only .net language that allows to use every aspect of CTS

Ref & Out Parameter in method
1.multiple out parameter can be returned from single method
2.Ref parameter required to be initialized
3.output parameter must be assigned by method being called and are passed by reference
void add(int x,int y,out int ans)
{ans=x+y}

Param keyword in method parameter
1.It allows programmer to pass into method an variable number of identical typed parameters
ex: methodane(param double[] value)

Array of object data type
object[] obj=new object[4]

Establish enumaration as byte to save storage in memory

Named Parameters
displayfancymessage(consolcolor textcolor,consolecolor backgroundcolor,string message)

Members of array class

1. Clear()-required to empty values
2. CopyTp()-copy elements from source array to destination array
3. length-returns number of items within array
4. Rank-returns number of dimensions of current array
5. reverse()-reverse content of one dimensional array
6. sort()-sorts one dimensional array of intrinsic type

Use of variable type in array
2.Size is not declared in var type

Array of interface
1.Ex:IPointy[] ipointyobjarray={new hexagon(),new Knife(),new Traingle()}
foreach(ipointy i in ipointobjarray)
{ console.writeline(i.points);
}}
2.Here all the classes implementing same interfaces

Inheriting multiple interface

1. for multiple interface having same method name scenario
2. interfacename.method name is used to distinguish method name
3. Interface can inherit another interface and the class inheriting sub interface has to implement all the members in the chain if interface
4. Interface can inherit multiple interface as well.class has to implement all the interface members in the chain

IEnumerator

1. System.collections comes with IENUMERATOR
2. looping through array of class foreach loop is not needed and using foreach loop instead of ienumerator will throw compilation error
   ex-public IENumerator GetEnumerator()
   {return cararray.getenumerator();
   }

Implicit typing of local variable

1. var keyword allows you to define local variable without explicitly defining the data type
2. the compiler determines the data type based upon initial assignment
3. varius terms available
   3.1. linq to objects-> this term refers to applying linq quries to arrays and collections
   3.2. Linq to xml->using linq to manipulate and query xml document
   3.3. linq to dataset->applying linq queries to ado.net dataset objects
   3.4. linq to entities->LINQ allows you to make use of linq quries within ado.net entity framework
   3.5. Parallel Linq->this allows parallel processing of data returned from linq query

asemblies for linq

1. system.core.dll->this is used for linq to objects
2. system.data.datasetextensions.dll->used for linq to datasets
3. system.xml.linq->used for linq to sql

Thread, asynchonous call

1. One appdomain can have multiple thread and thread can shift different app domain bounderies
2. single thread can not work in multiole app domain
3. when C# complier process delegate key word it invokes begineinvoke() and eninvoke() method
   public sealed class BinaryOp : System.MulticastDelegate
   {
   public IAsyncResult BeginInvoke( int x, int y, AsyncCallback cb, object state);
   // Used to fetch the return value // of the invoked method.
   public int EndInvoke( IAsyncResult result);
   }
   4.return type of endinvoke() will be same as delegate return type
4. Iasync result interface will be like below
   public interface IAsyncResult {
   object AsyncState { get; }
   WaitHandle AsyncWaitHandle { get; }
   bool CompletedSynchronously { get; }
   bool IsCompleted { get; } }
5. Iasync result comes with iscompleted property that helps calling thread to continue the job
   while(! iftAR.IsCompleted) { Console.WriteLine(" Doing more work in Main()!"); Thread.Sleep( 1000); }
6. Iasynch interface provides asyncwaithandler property
7. the benefit of waithandler.waitone() is that wait time can be specified,asynchronous call
8. asynchronouscallback object when passed as delegate parameter ,the delegate will call specified method automaticaly when the asynchronous call is completed
   IAsyncResult iftAR = b.BeginInvoke( 10, 10,new AsyncCallback( AddComplete), null);
9. starting object call with a new thread
   Thread backgroundThread = new Thread( new ThreadStart( p.PrintNumbers));

Thread synchronization

1. Lock keyword can be used to manage thread syncronization
   private object threadLock = new object(); public void PrintNumbers() {
   // Use the lock token.
   lock (threadLock) { ... }
2. CLR threadpool can be used instead of manually creating thread.
3. thread pool helps to manage threads by minimizing number of threads that must be created
4. using thread pool helps to focus on business problem instead of threading infrastructure
5. to queue a method ina worker thread threadpool.queueuserworkitem can be used
   public static bool QueueUserWorkItem( WaitCallback callBack);
   public static bool QueueUserWorkItem( WaitCallback callBack, object state);
6. waitcallback delegate can point to any method
7. TPL(Task parallel library) will automatically distribute application workload across available cpu dynamically using CLR thread pool
8. TPL handles partitioning of work,thread scheduling,state management and other low level details
9. system.threading.tasks comes with paralel class whcih will help to iterate over collection of data in parallel fashion
10. this parallel class support two static methods parallel.for() & parallel.foreach()
11. the benefit of parallel class is that it will pluck threads from thread pool
    Parallel.ForEach( files, currentFile = > { string filename = Path.GetFileName( currentFile);
    using (Bitmap bitmap = new Bitmap( currentFile)) {
    bitmap.RotateFlip( RotateFlipType.Rotate180FlipNone);
    bitmap.Save( Path.Combine( newDir, filename));
    Thread.CurrentThread.ManagedThreadId); } }
12. GUI control through windows forms always have thread affinity.if secondary thread directly attempts to access a control that they didnt create,itsa run time error
13. Through anonymous delegate secondary thread can access the GUI control.
    this.Invoke(( Action) delegate { this.Text = string.Format(" Processing {0} on thread {1}", filename, Thread.CurrentThread.ManagedThreadId); } );
14. In Above example TPL distributes workload among multiple threads from thread pool using as many CPUs
15. Alternative to asynchronous delegate is by using task class
    Task.Factory.StartNew(() = > { ProcessFiles(); });
16. The factory property of task returns taskfactory object when startnew() method called

Parallel LINQ Queries

1. Using AsParallel in Plinq query TPL will pass workload into available CPU
   int[] modThreeIsZero = (from num in source.AsParallel() where num % 3 = = 0 orderby num descending select num). ToArray();
2. using async and await keyword thread can be run in asynchronous way
   private async
   void btnCallMethod_Click( object sender, EventArgs e) { this.Text = await DoWork(); }
   // See below for code walkthrough... private Task < string > DoWork() { return Task.Run(() = > {Thread.Sleep( 10000); return "Done with work!"; }); }
3. using async keyword with task<T>
   private async Task < string > DoWorkAsync() { return await Task.Run(() = >
4. during await expression calling thread is suspended until awaited task is complete
   

FileInfo

1. Fileinfo class has create method which return filestream object
2. fileinfo.open() returns filestream object as well
3. fileinfo.opentext() returns streamreader type rather than filestream type
4. fileinfo has createtext() and appendtext() methods returns streamwriter object
5. readallbytes() returns binary data as array of bytes adn closes the file
6. readalllines() returns character data as array of strings
7. readalltext() returns character data as system.string

stream class

1. it has following properties
   1.1. canread/canwrite:determnes whether current stream supports reading/ writing
   1.2. close():closes current stream and releases any resources associated with stream
   1.3. flush():updates the datasource with current state of buffer and then flush it
   1.4. lenghth:provides lenghth of stream
   1.5. position:determines position of stream
   1.6. read()/readbyte():reads sequence of bytes from current stream
   1.7. seek() sets position in current stream
   1.8. setlenghth():sets length of current stream
   1.9. write()/writebyte():write sequence of bytes to current stream
   using( FileStream fStream = File.Open(" C:\ myMessage.dat", FileMode.Create)) {
   // Encode a string as an array of bytes.
   string msg = "Hello!"; byte[] msgAsByteArray = Encoding.Default.GetBytes( msg); // Write byte[] to file.
   fStream.Write( msgAsByteArray, 0, msgAsByteArray.Length); // Reset internal position of stream. fStream.Position = 0;
2. streamwriter and stream reader is needed when its needed to read/write character based data
   2.1. streamreader deerives from textreader as like stringreader
   2.2. streamwriter derives from textwriter

Binary reader/Writer

1. derive from system.object and allows to read and write Deseret data types into stream in a binary format
2. To notify any file change filesystemwatcher is used
   FileSystemWatcher watcher = new FileSystemWatcher();
   try { watcher.Path = " C:\ MyFolder"; }
   catch( ArgumentException ex) { Console.WriteLine( ex.Message); return; } // Set up the things to be on the lookout for.
   watcher.NotifyFilter = NotifyFilters.LastAccess| NotifyFilters.LastWrite | NotifyFilters.FileName | NotifyFilters.DirectoryName;
   watcher.Filter = "*. txt"; // Add event handlers.
   watcher.Changed + = new FileSystemEventHandler( OnChanged); watcher.Created + = new FileSystemEventHandler( OnChanged); watcher.Deleted + = new FileSystemEventHandler( OnChanged); watcher.Renamed + = new RenamedEventHandler( OnRenamed);

XMLSerialize

1. XMLAttribute: using xmlserializer to serialize the data as xmlattribute
2. xmlelement: this property or field serialized as xml element
3. xmlroot: this attribute controls how root element will be constructed
   

Dataset(disconnected layer)

1. dataset properties are
   acceptchanges()-commit all changes made to data set
   getchange()-returns copy of all changes since last loaded
   haschanges()-gets value whether dataset has changes
   readxml()-allows to define structure of dataset object and populate
   writexml()-write contents of dataset to valid stream
2. datacolumn has propertes like allowdbnull,autoincrement,caption,columnmapping,columnname
3. datatable reader works like data reader object and reads the data from datatable
4. to make datatable linq query compatible .use ASenumerable() extension method. this returns enumerablerowcollection object
   enumerablerowcollection enumdata=dataset.asenumerable();
5. maintenance of type safety required by using field<T>()
   ex: ID=car.field<int>("CARID");

connected layer

1. datareader: provides forward only readonly access data using server side cursor
2. dataadapter:transfer dataset between calleer and datastore.it contains connections and command objects
3. odbc: it is widespread model that provides access to data stores
4. open connection set for project
   static IDbConnection GetConnection( DataProvider dataProvider) {
   IDbConnection connection = null; switch (dataProvider) { case DataProvider.SqlServer: connection = new SqlConnection(); break; case DataProvider.OleDb: connection = new OleDbConnection(); break; case DataProvider.Odbc: connection = new OdbcConnection(); break; } return connection;

Entity Framework

1. DBContext:it represents unit of work and repository pattern that can be used to qury from database ad changes can be updated to database as group
2. dbcontext provides number of core services including the ability to save the changes,call sp,delete objects
3. dbcontext implements ibjectcontextadapter.so all its functionality available in objectconext class
4. To add tables in context dbset<T> is used
5. each dbset<T> provies number of core services
   5.1. addrange-allows to insert new object
   5.2. attach-associate object with dbcontext
   5.3. create<T>-create new instances of specific entity type
   5.4. findasync-finds data row by primary key and returns object representing taht row
   5.5. removerange-marks object for deletion
   5.6. sqlquery-creates raw sql query that will return entities
6. Using Linq to query with sql syntax
   foreach (Car c in context.Cars.SqlQuery(" Select CarId, Make, Color, PetName as CarNickName from Inventory
   where Make =@ p0", "BMW"))
7. each LINQ query hits the database. so to avoid hitting db, caching is used and data collected as Tolist<T>() or Toarray<T>()
   ex: var alldata=context.cars.ToArray();
8. lazy loading in EF prevents entire data to be loaded into memory
   ex: foreach (Car c in context.Cars) { foreach (Order o in c.Orders) { WriteLine( o.OrderId); }
   8.1. instead of loading all the car and orcer record,it will load only order specific to particular car
9. when its preferable to load all teh data into memory
   foreach (Car c in context.Cars.Include( c = > c.Orders)) { foreach (Order o in c.Orders) { WriteLine( o.OrderId); }
10. lazy loading can be disabled with
    context.Configuration.LazyLoadingEnabled = false;

Repository Pattern

1. its to mediate between domain and data mapping layers
2. Advantage of EF is all models and collections strongly typed
3. add baserepo to the directory which will implement common functionality for repository classes
4. retrieving records-getone/getoneasync and getall/getallasync is used to wrap the methods
   public T GetOne( int? id) = > Table.Find( id);
   public Task < T > GetOneAsync( int? id) = > Table.FindAsync( id);
   public List < T > GetAll() = > Table.ToList();
   public Task < List < T > > GetAllAsync() = > Table.ToListAsync();
5. baserepo implements idisposible interface which ensures resources released in timely manner
6. entitystate of the entity is to be modified into entitystate.modified and then call savechanges()
7. entuty state has to be changed to entitystate.deleted after calling delete() method
8. dropcreatedatabasealways()-this method always re creats database everytime programme is executed
9. dropcreatedatabaseifmodelchanges<TContext> only recreates when there is any changes in the model

bundling

1. process of combining multiple files into one
2. This will help in speeding up the site
3. minification: its designed to speed up load time for web pages
   3.1.minification is the process of replacing long names with short names
4. Bootstrap: its an open source HTML,CSS,Javascript framework for developing responsive mobile first websites
5. bootstrap ships with glyphlcons halfling fornt sets that is used to enhance application UI
   6.routing can be done to reroute some of urls
   routes.maproute("contact","contact/{*pathinfo}",new{controller="Home",action="contact"})
   6.1. pathonfo allws to pass any parameter into it
6. redirectiing to other users can be done using html link
   html.actionlink("contact","contact",Home")
7. 
   
   
   
   

Model Binding
1.There is implicit and explicit binding

2. model binding engine attempts to assign values.if it cant assiign model state.isvalid=false.
3. if it successfully assigned modelstate.isvalid=true
4. if model can't be bound it throws error like modelstate.addmodelerror(string.empty,<head>quot;unable to create record:{ex.message}");
5. antiforgerytoken is used in forms to avoid hacking
6. fields can be black/white listed during binding
   public async Task<ActionResult>Create([Bind(Include="Make,clor")]Inventory inventory)

MVC Controller & Views

1. MVC views can be built using razor view engine / web forms view engine
2. Razor view is designed as improvement over web forms view
3. Razor is template markup syntax that is interpreted to c#
4. using razor in html/ css results in cleaner and easier to read mark up
5. Razor uses @ instead of <%%>
6. code blocks can intermix markup and code.lines that begin with markup tag are interpreted as HTML
7. lines that are begin with code are interpreted as code
   foreach (var item in Model) { int x = 0; < tr > </ tr > }
8. razor html helper renders mark .The helper can output details of inventory record
   using AutoLotDAL.Models
   helper ShowInventory( Inventory item)
   { item.Make < text >-</ text >@ item.Color < text >( </ text >@ item.PetName < text >) </ text >
9. Razor can have functions to encapsulate code
   functions
   { public IList < Inventory > SortCars( IList < Inventory > cars)
   { var list = from s in cars orderby s.PetName select s;
   return list.ToList(); } }
10. foreach loop can use the functions in the page
    foreach (var item in SortCars( Model.ToList()))
    { <!-- rest removed for brevity --> }

Razor partial view

1. useful to encapsulating UI that reduces repeating code
2. partial view rendered from action method where as full view will use a layout page
3. 
   

ways to send data to view

1. TempData:short lived object works between current and next request
2. ViewData:It allows storing name value pairs
3. ViewBag:its a dynamic wraper for view data dictionary
4. For large amount of data model property is used
5. glyphlcons are ste of icons that ships with bootstrap

Web API

1. Json is one way to transport data between services
2. its a key value text representation of objects and classes
3. webapi is centered on controller and actions
4. in addition to httpget and http post httpput and httpdelete are used
5. creating view models using automaper
   public InventoryController()
   { Mapper.Initialize(
   cfg = > { cfg.CreateMap < Inventory, Inventory >() .ForMember( x = > x.Orders, opt = > opt.Ignore()); }); }
6. above code creates mapping for inventory type ignoring order property
7. responsetype attribute is used to specify the entity type returned in httpresponsemessage
8. nofound() returns not found result that translates to 404 message
9. calling through httpclient to web api. webapi returns two properties
10. issuccessstatuscode property returns as true
11. the content property provides access to message body and if the result records returned,web api returns as httpok(200)
12. the content property always holds the record in jason format
13. httpclient have to use jsonconvert.deserializeobject<T>() method
14. for updating add action system.net.http.formatting is needed as project reference
15. for add postasjsonsync() is needed to add the data
16. putasjsonasync() is needed for updating record using httpclient
17. deleteassync() is needed to be used in client when you need to delete the record
18. httprequestmesage take two parameter
    **httpmethod & and the url
    HttpRequestMessage request = new HttpRequestMessage( HttpMethod.Delete, $" http:// localhost: 46024/ api/ Inventory/{ inventory.CarId }") { Content = new StringContent( JsonConvert.SerializeObject( inventory), Encoding.UTF8, "application/ json") };**