Code Ink

Calling function from your angularjs directive

var module = angularjs.module('myApp',[]);
module.directive('myCustomFunction',['$parse', function($parse) {
return {
scope : false, // no isolated scope
replace : false,
link:function(scope, element, attr) {
    element.click = function() {
        // Calling function parsing the expression first and then 
        // executing the expression under directive scope here 
        // directive scope is parent controller scope
        $parse(attr.myCustomFunction)(scope);
    };
};
}]);

module.directive('myCustomFunction',['$parse', function($parse){
return {
scope : {
    // Isolated scope binding a function to scope variable
    myCustomFunction : '&'
},
replace : false,
link : function(scope, element, attr) {
    element.click = function() {
        // Calling bind function
        scope.myCustomFunction();
    };
};
}]);

<button my-custom-function="someControllermethod()">My Custom Directive example</button>

Mongo ( mongo.exe )

Insert a document in product collection and then update it using help of javascript object.

> db.product.insert({ "_id" : "ac3", "name" : "AC3 Phone", "brand" : "ACME", "type" : "phone", "price" : 200, "warranty_years" : 1, "available" : true })

> p = db.product.findOne({"_id":"ac3"}) // set to find document
> p.price = 199  // update price field
> p.warranty_years = 2
> db.product.save(p) // update product into database ... easy hum.

Writing multiline script in shell

> db.product.update({ "_id" : "ac3"},
... { "_id" : "ac3", "name" : "AC3 Phone", "brand" : "ACME", "type" : "phone",
... "price" : 200, "warranty_years" : 1, "available" : true })

See method implementation details to know more

> db.getCollectionNames  // use to get collection names present in current database

function (){
    var all = [];

    var nsLength = this._name.length + 1;

    var c = this.getCollection( "system.namespaces" ).find();
    while ( c.hasNext() ){
        var name = c.next().name;

        if ( name.indexOf( "$" ) >= 0 && name.indexOf( ".oplog.$" ) < 0 )
            continue;

        all.push( name.substring( nsLength ) );
    }

    return all.sort();
}

Running javascript file with mongo shell

mongo <databasename> <your_js_file>

mongo <databasename> <your_js_file> >> <result_file>

printjson( db.product.find());

Conclusion

Download the Mongodb package from here

Running mongod instance server

Lets write the first code to connect to our mongodb server

namespace MongoFirst
{
    using MongoDB.Bson;
    using MongoDB.Driver;
    using System;

    public class Program
    {
        static void Main(string[] args)
        {
            // create a client object
            MongoClient client = new MongoClient("mongodb://localhost:27017/"); // mongodb connection string
            // create a server object
            MongoServer server = client.GetServer();
            // create a database object with database name "test"
            MongoDatabase db = server.GetDatabase("test");
            // get collection object cars from test database
            MongoCollection cars = db.GetCollection("cars");
            // insert documents
            cars.Save(new Cars { Name = "Mongodb" });
            cars.Save(new Cars { Name = "Oracle" });

            // loop throug each item in cars collection
            foreach (var car in cars.FindAllAs())
            {
                Console.WriteLine("Database : {0}", car.Name);
            }

            Console.ReadKey();
        }
    }

    public class Cars
    {
        // a collection always have a field '_id' in mongodb, 
        // you can also use different type rather that ObjectId here
        public ObjectId Id { get; set; } 
        public string Name { get; set; }
    }
}

The way of running asynchronous operation from C# 5.0 is now has dramatic changes. Specifically there are two new operators async and await introduce by C# 5.0 language to support linear asynchronous programming model.

async

operator use as a modifier to specify that a method, lambda expression, or anonymous method is asynchronous.If you use this modifier on a method or expression, it's referred to as an asynchronous method.

await

operator is applied to a task in an asynchronous method to suspend the execution of the method until the awaited task completes. The task represents ongoing work.

public async void DoSomething()
{
    string result = await obj.GetResultAsync(); // return immediately to calling code
    Console.WriteLine(result); // execution continue from here once above work completed 
}

public async void DoSomething()
{
    // obj - any object that have GetAwaiter method with appropriate return type
    var temp = obj.GetAwaiter(); 
    if (!temp.IsCompleted)
    {
        SAVE_STATE()
        temp.OnCompleted(&cont);
        return;
        cont:
        RESTORE_STATE()
        result = temp.GetResult();
        Console.WriteLine(result); // code below await expression
    }
}

Here program try to get the awaiter instance from the asynchronous method. This instance temp has an IsCompleted boolean property member which is use to determine if asynchronous task execution completes. If it return false the program store the current machine state and inject an Action (&cont) delegate by using OnCompleted() method of the awaiter instance. Note that this method is part of INotifyCompletion interface. Once the blocking operation execution completes program restore the machine state and get output result by calling GetResult() on awaiter instance. Further program continue below the await statement where its left control.

Condition that compiler check when we use await operator

1. It check if the return type of await expression does have GetAwaiter() method. This method can also be a extension method for the instance type.
2. GetAwaiter() must return type that have boolean type property IsCompleted.
3. Return type of GetAwaiter() must implement INotifyCompletion interface.
4. Return type of GetAwaiter() must have GetResult() method that return instance of expected type by await expression

oTable = $('#tableid').dataTable({
                "bProcessing": true,
                "bServerSide": true,
                "sServerMethod": "POST",
                "sAjaxSource": "/data/debtors",
                "aoColumnDefs": [
                    { "mDataProp": "Debtor", "aTargets": [0] },
                    { "mDataProp": "Iban", "aTargets": [1] },
                    { "mDataProp": "Bic", "aTargets": [2] }
                ],
                "aaSorting": [[1, 'desc']]
               });
oTable.fnAddSearchBox($("#exampleSearch"),
                        {
                          option:{"1":{ tip:'please enter IBAN'},
                                  "2":{ tip:'please enter BIC'}}
                        });

<div id="exampleSearch"  title="Search">
    <div>
        <input id="Name" type="checkbox" value="1" />
        <label class="sfieldslbl">Iban</label>
    </div>
    <div>
        <input id="Address" type="checkbox" value="2" />
        <label class="sfieldslbl">Bic</label>
    </div>
</div>

$(document).ready(function(){
$("#tableid").datatable();
});

<link href="@Url.Content("~/media/css/jquery.dataTables_themeroller.css")" rel="stylesheet" type="text/css" />

<script src="@Url.Content("~/media/js/jquery.dataTables.min.js")" type="text/javascript"></script>

@{Html.Grid(Model).Columns(column =>
  {
      column.For(c => c.DebtorName).Named("Debtor");
      column.For(c => c.Iban);
      column.For(c => c.Bic);
      column.For(c => c.IsDeleted).Named("Hidden");
  }).Attributes(id => "tableid").Render();
 }

oTable = $('#tableid').dataTable({
                "bProcessing": true,
                "bServerSide": true,
                "sServerMethod": "POST",
                "sAjaxSource": "/data/debtors",
                "aoColumnDefs": [
                    { "mDataProp": "Debtor", "aTargets": [0] },
                    { "mDataProp": "Iban", "aTargets": [1] },
                    { "mDataProp": "Bic", "aTargets": [2] }
                ],
                "aaSorting": [[1, 'desc']]
               });

[Post]
public JsonResult debtors()
{
   return View(GetAllDebtor().Select(d=> new {Debtor = c.debitor,Iban=c.iban,Bic=c.bic}));
}

public class GridRequestModelBinder : ModelBinderBase, IModelBinder
    {
        public object BindModel(ControllerContext controllerContext, ModelBindingContext bindingContext)
        {
            GridRequest GridrequestObject = new GridRequest();
            // iColumns no of cols
            GridrequestObject.iColumns = Convert.ToInt32(GetValue(bindingContext, "", "iColumns"));
            //iDisplayLength
            GridrequestObject.iDisplayLength = Convert.ToInt32(GetValue(bindingContext, "", "iDisplayLength"));

            //iDisplayStart
            GridrequestObject.iDisplayStart = Convert.ToInt32(GetValue(bindingContext, "", "iDisplayStart"));

            //bregex
            GridrequestObject.bRegex = Convert.ToBoolean(GetValue(bindingContext, "", "bRegex"));

            //bregex_params
            GridrequestObject.bRegex_params = GetValue(bindingContext, "_", "bRegex", GridrequestObject.iColumns);

            //bSearchable

            GridrequestObject.bSearchable_params = GetValue(bindingContext, "_", "bSearchable", GridrequestObject.iColumns);

            //iSortingCols ** 1
            // iSortingCols 
            GridrequestObject.iSortingCols = Convert.ToInt32(GetValue(bindingContext, "", "iSortingCols"));
            //iSortCol_param * 1
            GridrequestObject.iSortCol_params = GetValue(bindingContext, "_", "iSortCol", GridrequestObject.iSortingCols);

            //bSortable
            GridrequestObject.bSortable_params = GetValue(bindingContext, "_", "bSortable", GridrequestObject.iColumns);

            //sSortDir_params * 1
            GridrequestObject.sSortDir_params = GetValue(bindingContext, "_", "sSortDir", GridrequestObject.iSortingCols);
            //mDataProp_params
            GridrequestObject.mDataProp_params = GetValue(bindingContext, "_", "mDataProp", GridrequestObject.iColumns);

            //sColumns 
            GridrequestObject.sColumns = GetValue(bindingContext, "", "sColumns");
            //sEcho 
            GridrequestObject.sEcho = Convert.ToInt32(GetValue(bindingContext, "", "sEcho"));
            //sSearch
            GridrequestObject.sSearch = GetValue(bindingContext, "", "sSearch");
            // sSearch_params
            GridrequestObject.mDataProp_params = GetValue(bindingContext, "_", "mDataProp", GridrequestObject.iColumns);

            // sSearch_params
            GridrequestObject.sSearch_params = GetSearchParams(bindingContext, GridrequestObject.mDataProp_params);

            return GridrequestObject;
        }

        private Dictionary<string,string> GetSearchParams(ModelBindingContext bindingContext, Dictionary<string,string> Propdictionary)
        {
            Dictionary<string,string> RetDicxs = new Dictionary<string,string>();
            for (int i = 0; i < Propdictionary.Count; i++)
            {
                RetDicxs.Add(Propdictionary["mDataProp_" + i.ToString()], GetValue(bindingContext, "_" + i.ToString(), "sSearch"));
            }
            return RetDicxs;
   }

public class ModelBinderBase
    {
        public string GetValue(ModelBindingContext context, string postfix, string key)
        {
            ValueProviderResult vpr = context.ValueProvider.GetValue(key + postfix);
            return vpr == null ? null : vpr.AttemptedValue;
        }

        public Dictionary<string,string> GetValue(ModelBindingContext context, string postfix, string key, int MaxParam)
        {
            Dictionary<string,string> RetDicxs = new Dictionary<string,string>();
            for (int i = 0; i < MaxParam; i++)
            {
                RetDicxs.Add(key + postfix + i.ToString(), GetValue(context, postfix + i.ToString(), key));
            }
            return RetDicxs;
        }
    }
public class GridRequest
    {
        public bool bRegex { get; set; } // Regular expression for _sSearch Text
        public Dictionary<string,string> bRegex_params { get; set; } // Regular expression for _sSearch[i] Text

        private string _sSearch; // text of search box
        public bool bSearchable { get; set; } // do client want to search
        public string sSearch
        {
            get { return _sSearch; }
            set { _sSearch = value == null ? "" : value; }
        }
        public Dictionary<string,string> bSearchable_params { get; set; } // do client want to search on particular column with different search text
        public Dictionary<string,string> sSearch_params; // search on particular column with different search text

        public int iSortingCols { get; set; }
        public Dictionary<string,string> iSortCol_params { get; set; }
        public Dictionary<string,string> bSortable_params { get; set; }
        public Dictionary<string,string> sSortDir_params { get; set; }

        public int iColumns { get; set; }
        public string sColumns { get; set; }

        public int sEcho { get; set; }
        public int iDisplayStart { get; set; } // Start Index
        public int iDisplayLength { get; set; } // Complete number of records

        public Dictionary<string,string> mDataProp_params { get; set; }
    }

ModelBinders.Binders.Add(new typeof(GridRequest), new GridRequestModelBinder());

public JsonResult debtors(GridRequest greq)
{
  return View(GetAllDebtor()
 .Where(d=>d.debitor.Contains(greq.sSearch)||d.iban.Contains(greq.sSearch)||d.bic.Contains(greq.sSearch)
 .Select(d=> new {Debtor = c.debitor,Iban=c.iban,Bic=c.bic}));
}

• A remote proxy acts as local representative of remote object, and abstracts away the details of communicating with remote object.
• A virtual proxy creates expensive objects on demand. A common example is an Image Proxy that show a placeholder while the Image is being loaded.
• A Protection Proxy can be used to control access to an object, based on authorization rules.

• Clients work with Proxy as if it were the actual object. Usually the proxy object have common interface with real object.
• This pattern also use to control the access to the actual object and delegated the calls to it as needed. This also mean that Proxy pattern support the Open Close system i.e., the object is open for extension but close for modification.
• This pattern is use to- Improve performance and load time of an application, Simplify interactions with with remote objects, defer expensive calls until needed- implement lazy loading of objects from persistence.   
  

• Client code does not need to be changed to work with a proxy object because proxy will give the same interface or structure like real object when replacing the real object. However, proxy object must be synchronized with the real object. The proxy object adsorb the change in real object and continue to support the same interface expose to the client. 
• Proxy may be used to optimize performance in existing system without touching existing class behavior this means that proxy pattern support Open/Close Principle i.e., extension can be possible but modification can't.
• Client code may make incorrect assumption about behavior of real object as proxy object masked the real object behavior. The interface use by the proxy may describe the interface methods in such a way that it may use many calls to real object method rather than few, large call. This gives rise born of the two different interface which may be implemented by the proxy pattern one is chatty another is chunky. While use Chatty type interface proxy do many small calling to real object method and while use Chunky type interface proxy do less number of calling to real object method.
• A disadvantage of using chatty interface is that it may required more database calls than necessary.