destroy: {
                        url: function (blog) {
                            return "@Url.Action("DeleteBlog","Admin")/" + blog.id;
                        },
                        contentType: 'application/json; charset=utf-8',
                        type: "DELETE"
                    },

 $("#report-grid").kendoGrid({
                dataSource: blogDataSource,
                autoBind: true,
                scrollable: false,
                pageable: true,
                sortable: true,
                filterable: true,
                reorderable: true,
                selectable: true,
                editable: {
                    confirmation: "آیا مایل به حذف ردیف انتخابی هستید؟",
                    destroy: true, // whether or not to delete item when button is clicked
                    mode: "popup" // options are "incell", "inline", and "popup"

  [HttpDelete]
  [ValidateAntiForgeryToken]
  public async Task<IActionResult> DeleteBlog(long id)
  {
          var blog = _blogRepository.Get(id);
          if (blog == null)
            return NotFound();
            blog.IsDeleted = true;
          _blogRepository.Update(blog);
           await _unitOfWork.SaveAsync();
           return Json(blog);
  }

       public static string EscapeXml(string s)
       {
           var xml = s;
           if (!string.IsNullOrEmpty(xml))
           {
               // replace literal values with entities
               xml = xml.Replace("&", "&");
               xml = xml.Replace("<", "&lt;");
               xml = xml.Replace(">", "&gt;");
               xml = xml.Replace("\"", "&quot;");
               xml = xml.Replace("'", "&apos;");
           }
           return xml;
       }

<table>
<tr>
 <td>data
  </td>
</tr>

<table> <tr> <td>data</td> </tr>

private static readonly Regex REGEX_BETWEEN_TAGS = new Regex(@">\s+<", RegexOptions.Compiled);
private static readonly Regex REGEX_LINE_BREAKS = new Regex(@"\n\s+", RegexOptions.Compiled);
public static string RemoveSpaces(string html)
{
  html = REGEX_BETWEEN_TAGS.Replace(html, "> <");
  return REGEX_LINE_BREAKS.Replace(html, string.Empty);

}

txtMod.Text = txtOrig.Text.Replace((char)160, ' ');

using System.Data.Entity.Core.Metadata.Edm;

public class SoftDeleteAttribute : Attribute
    {
        public string ColumnName { get; set; }
        public SoftDeleteAttribute(string column)
        {
            ColumnName = column;
        }
        public static string GetSoftDeleteColumnName(EdmType type)
        {
            MetadataProperty column = type.MetadataProperties.Where(x => x.Name.EndsWith("customannotation:SoftDeleteColumnName")).SingleOrDefault();
            return column == null ? null : (string)column.Value;
        }
    }

    [SoftDelete("IsDeleted")]
    public class TblUser 
    {        
        [Key]
        public int TblUserID { get; set; }

        [MaxLength(30)]
        public string Name { get; set; }

        public bool IsDeleted { get; set; }
    }

 protected override void OnModelCreating(DbModelBuilder modelBuilder)
        {
            var Conv = new AttributeToTableAnnotationConvention<SoftDeleteAttribute, string>(
                "SoftDeleteColumnName",
                (type, attribute) => attribute.Single().ColumnName);
            modelBuilder.Conventions.Add(Conv);

        }

 <EntityType Name="TblUser" customannotation:SoftDeleteColumnName="IsDeleted">

public class SoftDeleteInterceptor : IDbCommandTreeInterceptor
    {
        public void TreeCreated(DbCommandTreeInterceptionContext interceptionContext)
        {
            if (interceptionContext.OriginalResult.DataSpace == System.Data.Entity.Core.Metadata.Edm.DataSpace.SSpace)
            {
                var QueryCommand = interceptionContext.Result as DbQueryCommandTree;
                if (QueryCommand != null)
                {
                    var newQuery = QueryCommand.Query.Accept(new SoftDeleteQueryVisitor());
                    interceptionContext.Result = new DbQueryCommandTree(QueryCommand.MetadataWorkspace, QueryCommand.DataSpace, newQuery);
                }
            }
       }
}

  public class SoftDeleteQueryVisitor : DefaultExpressionVisitor
    {
        public override DbExpression Visit(DbScanExpression expression)
        {
            var column = SoftDeleteAttribute.GetSoftDeleteColumnName(expression.Target.ElementType);
            if (column!=null)
            {
                var Binding = DbExpressionBuilder.Bind(expression);
                return DbExpressionBuilder.Filter(Binding, DbExpressionBuilder.NotEqual(DbExpressionBuilder.Property(DbExpressionBuilder.Variable(Binding.VariableType, Binding.VariableName), column), DbExpression.FromBoolean(true)));
            }
            else
            {
                return base.Visit(expression);
            }
        }
    }

 public class DbContextConfig : DbConfiguration
    {
        public DbContextConfig()
        {
             AddInterceptor(new SoftDeleteInterceptor());
        }
    }

var app = angular.module('myApp', []);

app.factory('BookData', function () {
    var books = [
        { code: 1, name: 'book1', },
        { code: 2, name: 'book2', },
        { code: 3, name: 'book3', },
        { code: 4, name: 'book4', },
        { code: 5, name: 'book5', }
    ];
    return books;    
});

app.controller('controller1', function ($scope, BookData) {
    $scope.books = BookData;
});

app.controller('controller2', function ($scope, BookData) {
    $scope.books = BookData;
});

<script type="text/javascript" src="~/scripts/app/controller1.js"></script>  


<div ng-app="myApp">    
    <div ng-controller="controller1">
        <p>Data from controller1</p>
        <table>
            <tr ng-repeat="book in books">
                <td>
                    {{book.code}}
                </td>
                <td>
                    {{book.name}}
                </td>
            </tr>
        </table>
    </div>

    <div ng-controller="controller2">
        <p>Data from controller2</p>
        <table>
            <tr ng-repeat="book in books">
                <td>
                    {{book.code}}
                </td>
                <td>
                    {{book.name}}
                </td>
            </tr>
        </table>
    </div>
</div>

var unicorn = {
   legs: 4,
   color: 'brown',
   horn: true
};

var proxyUnicorn = new Proxy(unicorn, {
      get: function(target, property) {
            if(property === 'color') {
                  return 'awesome ' + target[property];
              } else {
                  return target[property];
           }
      }
});

var proxyUnicorn = new Proxy(unicorn, {
           set: function(target, property, value) {
                    if(property === 'horn' && value === false) {
                         console.log('unicorn cannot ever lose its horn!');
                      } else {
                         target[property] = value;
                      }
           }
});

var unicorn = {
   legs: 4,
   color: 'brown',
   horn: true,
   hornAttack: function(target) {
        return target.name + ' was obliterated!';
   }
};

unicorn.hornAttack = new Proxy(unicorn.hornAttack, {
        apply: function(target, context, args) {
                  if(context !== unicorn) {
                     return 'nobody can use unicorn horn but unicorn!';
                   } else {
                     return target.apply(context, args);
                 }
        }
});