Saturday, July 29, 2017

The statement "use strict"; : List of features (non-exhaustive)



The statement "use strict"; instructs the browser to use the Strict mode, which is a reduced and safer feature set of JavaScript.

List of features (non-exhaustive)

  1. Disallows global variables. (Catches missing var declarations and typos in variable names)
  2. Silent failing assignments will throw error in strict mode (assigning NaN = 5;)
  3. Attempts to delete undeletable properties will throw (delete Object.prototype)
  4. Requires all property names in an object literal to be unique (var x = {x1: "1", x1: "2"})
  5. Function parameter names must be unique (function sum (x, x) {...})
  6. Forbids octal syntax (var x = 023; some devs assume wrongly that a preceding zero does nothing to change the number.)
  7. Forbids the with keyword
  8. eval in strict mode does not introduce new variables
  9. Forbids deleting plain names (delete x;)
  10. Forbids binding or assignment of the names eval and arguments in any form
  11. Strict mode does not alias properties of the arguments object with the formal parameters. (i.e. in function sum (a,b) { return arguments[0] + b;} This works because arguments[0] is bound to a and so on. )
  12. arguments.callee is not supported
[Ref: Strict modeMozilla Developer Network]

Wednesday, July 5, 2017

SOLVED: System.IO.FileLoadException exception by unblocking the files


When I was trying to uninstall windows service using InstallUtil.exe (This can also happen when you try to install a windows service). I was getting an error. Please read the complete story.

The command I was trying was,

installutil -u  SearchIndexService.exe

The error was,

Microsoft (R) .NET Framework Installation utility Version 4.0.30319.17929
Copyright (C) Microsoft Corporation.  All rights reserved.

Exception occurred while initializing the installation:
System.IO.FileLoadException: Could not load file or assembly 'IDM365SearchIndexService.exe' or one of its dependencies. Operation is not supported. (Exception from HRESULT: 0x80131515).

After lot of research on internet I have found following solution, You need to run following power shell command for the folder where you want to do the operation.

 get-childitem -recurse *.* | Unblock-File

The command simply unblocks the file.

You can verify the problem & solution by looking at the properties of the target file. it should show something as highlighted in following image.



After you run the command   get-childitem -recurse *.* | Unblock-File it should disappear.
After all this exercise you should be able to install/uninstall windows services.

Thanks
Happy Programming :)



Wednesday, August 3, 2016

Use of Checked and Unchecked keyword in C#



Here I am going to explain what the use of checked and unchecked keyword in C#. Here I am taking the some content from MSDN to explain about it. A checked context, arithmetic overflow raises an exception. In an unchecked context, arithmetic overflow is ignored and the result is truncated.
  • Checked Specify checked context.
  • unchecked Specify unchecked context.
The following operations are affected by the overflow checking:
  • Expressions using the following predefined operators on integral types:
    ++ — - (unary) + - * /
  • Explicit numeric conversions between integral types.
The checked/unchecked compiler option lets you specify checked or unchecked context for all integer arithmetic statements that are not explicitly in the scope of a checked or unchecked keyword. Now I am going to explain one by one.
Checked
The checked keyword is used to control the overflow-checking context for integral-type arithmetic operations and conversions. It can be used as an operator or a statement according to the following forms.

The checked statement:
checked block
The statement block that contains the expressions to be evaluated in a checked context.
The checked operator:
checked (expression)
The expression to be evaluated in a checked context. Notice that the expression must be in parentheses ( ).
Unchecked
The unchecked keyword is used to control the overflow-checking context for integral-type arithmetic operations and conversions. It can be used as an operator or a statement according to the following forms.

The unchecked statement :
unchecked block
The statement block that contains the expressions to be evaluated in an unchecked context.

The unchecked operator :
unchecked (expression)
The expression to be evaluated in an unchecked context. Notice that the expression must be in parentheses ( ).
Example
namespace Checked_Unchecked
{
    class Program
    {
        public short a = 30000;
        public short b = 20000;
        public short c;

        public int Add()
        {
            try
            {
                c = checked((short)(a + b));

            }
            catch (System.OverflowException e)
            {
                System.Console.WriteLine(e.ToString());
            }
            return c;
        }

        public int Mul()
        {
            try
            {
                checked
                {
                    c = (short)(a * b);
                }
            }
            catch (System.OverflowException e)
            {
                System.Console.WriteLine(e.ToString());
            }
            return c;
        }

        public int Add_Unchecked()
        {
            try
            {
                c = unchecked((short)(a + b));

            }
            catch (System.OverflowException e)
            {
                System.Console.WriteLine(e.ToString());
            }
            return c;
        }

        public int Mul_Unchecked()
        {
            try
            {
                unchecked
                {
                    c = (short)(a * b);
                }
            }
            catch (System.OverflowException e)
            {
                System.Console.WriteLine(e.ToString());
            }
            return c;
        }

        static void Main(string[] args)
        {
            Program p = new Program();

            // For checked
            Console.WriteLine("Checked output value is: {0}", p.Add());
            Console.WriteLine("Checked output value is: {0}", p.Mul());
            // For Unchecked
            Console.WriteLine("Checked output value is: {0}", p.Add_Unchecked());
            Console.WriteLine("Checked output value is: {0}", p.Mul_Unchecked());
            Console.ReadKey(true);
        }
    }
}

Output

Image1.jpg

Thursday, July 28, 2016

Making App_GlobalResources -> .RESX public


Regarding the previous post you may want to use strings from a global resources.resx file (App_GlobalResources) as error messages or descriptions in your attributes. This won’t work because global resource files are by default marked as internal and so you can’t access them from your controller or your model. Also the little “Access Modifier” dropdown menu in the resource editor is grayed out, so you can’t change the access level without further ado.

However there’s a way to change the access rights without editing the designer file by hand.
You just have to open the file properties of the resource file and change the “Custom Tool” from “GlobalResourceProxyGenerator” to “PublicResXFileCodeGenerator”, which is the default Tool for local resource files. Next you have to change the “Build Action” to “Embedded Resource”. You may also want to assign a proper Custom Tool Namespace like “Resources” in order to access the file properly, but this isn’t necessary.


Now rebuild the project and you should notice that the resource access is now public and you can access its contents from anywhere in your project.
E.g. like that:


[Required(ErrorMessageResourceType = typeof(Resources.Resource1)
, ErrorMessageResourceName = "Comment_Text")]
public string Myproperty { get; set; }

Solve Cannot retrieve property 'Name' because localization failed. Type 'YourResourceFile' is not public or does not contain a public static string property with the name 'YourItemName'.

Data Annotations are a great thing. They allow you to add information to your model quickly and easily. However, if you have an application that is designed for multiple cultures, you cannot add a Name to your annotation and have it display appropriately for other cultures. It is easy to use App_GlobalResources to hold your global strings, however, you may encounter the following message when using an App_GlobalResources folder in Asp.Net MVC -

        [Required(
            ErrorMessageResourceName = "Required_PleaseSelectA", 
            ErrorMessageResourceType = typeof(StringResources))]
        [StringLength(100, 
            ErrorMessageResourceName = "Length_YourMustBeACombination", 
            ErrorMessageResourceType = typeof(StringResources), 
            MinimumLength = 6)]
        [Display(
            ResourceType = typeof(LocalizedResources), 
            Name = "CategoryName", 
            Description = "CategoryName")]
        public string CategoryName { get; set; }
Cannot retrieve property 'Name' because localization failed.  Type 'Resources.StringResources' is not public or does not contain a public static string property with the name 'CategoryName'.

In this particular example, I set up resources for a property called CategoryName.
This error is VERY simple to solve. The resource file needs to be made public.
To do this, you will need to change the TYPE of tool used to generate the resource file.

In Asp.Net MVC 4, when you add a App_GlobalResources folder and create a resource file in it, by default the resource file is set up as internal and given theGlobalResourceProxyGenerator as a tool. That internal designation creates a problem for the DisplayAttribute annotation because it checks to see if the ResourceType is visible. In fact, it actually uses Type.IsVisible. This creates a problem because the internal class is NOT visible to it.

Now here is an interesting thing to note. The RequiredAttribute and StringAttributeboth inherit from ValidationAttribute. The DisplayAttribute does NOT. The Required and String Attributes utilize a different mechanism to connect with the resource files. You can see subtle differences when you look at how the items are set up again -

        [Required(
            ErrorMessageResourceName = "Required_PleaseSelectA",
            ErrorMessageResourceType = typeof(StringResources))]
        [StringLength(100,
            ErrorMessageResourceName = "Length_YourMustBeACombination",
            ErrorMessageResourceType = typeof(StringResources),
            MinimumLength = 6)]

        [Display(
            ResourceType = typeof(StringResources),
            Name = "CategoryName",
            Description = "CategoryName")]

        public string CategoryName { get; set; }

Notice that each resource file in the photo of App_GlobalResources above has a .cs file attached to it.When you click on that resource file,  you see that all of the classes are internal. If you change the CustomTool to PublicResXFileCodeGenerator and rebuild your application, you will see the .cs file go from internal to public and your DisplayAttribute will be able to connect with the resource file now. In fact, if you click on the .cs file to open it AND change then go over to properties and change the CustomTool, all of the items in the file will automagically change from internal to public.

The difference between DisplayNameAttribute and MVC 3 new DisplayAttribute


You may already know that ASP.NET MVC 2 introduced the DisplayNameAttribute which is part of the System.ComponentModel namespace. This attribute allowed us to display the name of the customer as the “Customer Name” instead of the actual property name: “Name”.
mvc display name attribute
ASP.NET MVC 3 now supports DisplayAttribute in System.ComponentModel.DataAnnotation namespace. DisplayAttribute is new in .NET 4.
mvc display attribute
So what is the real difference between the “DisplayAttribute”, and the “DisplayNameAttribute”? They serve the same purpose, which is displaying a custom string, however the key difference is in the overloads they provide.
“DisplayAttribute” supports more overloads than the DisplayNameAttribute”.
display attribute param overload
DisplayNameAttribute” only supports a string which is the DisplayName.
display-name-attribute-param
Even though it doesn’t make sense to do so, what happens if we were to specify both attributes?
mvc display & display name attribute
In this situation, the new DisplayAttribute takes precedence over the DisplayNameAttribute. Instead of the “Customer name 2” we should see the “Customer name 1” displayed to the user.
Handing Resources
In some cases, we need the DisplayAttribute to be resource sensitive. For an example, instead of using non-localized resources, we might want to use the standard .NET resource provider to retrieve the localized resources. 
display-attribute
Below is a simple example on how to configure the resources so they can be displayed based on the localization.
resource-handling
image
As we did for the above DisplayAttribute, it is not straightforward to make DisplayNameAttribute to be resource sensitive. DisplayNameAttribute does not support a parameter for ResourceType. In that case, we need to subclass the DisplayNameAttribute and provide our own implementation similar to below.
image
Below is the usage of new sub classed attribute:
image