Archive for June 2015
Udemy

Disable textbox cut copy paste in asp.net and asp.net mvc using javascript,jquery

Thursday, June 18, 2015 0 Comments A+ a-

In some scenarios, we don't want user to be able to cut or copy the value of text box and we also want to restrict user to not be able to paste value from clipboard in text box.


User have couple of options, he can use short cut keys , for example Ctrl + C for copying and Ctrl + V , or user can right click inside the control and can use use context menu buttons which are mostly Cut, Copy and Paste available for doing desired operation on control.


One way is to write java-script events  for cut,copy and paste so that whenever user do one of these operations on control we handle them to override the default implementation of these commands.



In asp.net mvc we can use the htmlAttributes parameter of Html Helper method do it.

Disabling Using  JavaScript:


Here is an example code using javacript:

@Html.TextBoxFor(model => model.Question, 
          new {
                       @class="form-control",
                       oncut="return false"
                       oncopy="return false", 
                       onpaste="return false"
                     }
                 )

Here is the Live DEMO Fiddle of it.


Disabling Using JQuery:


We can do the same using jquery as well this way:

@Html.TextBoxFor(model => model.Question, 
          new {
                       @class="form-control",
                       id="txtQuestion"
                       oncut="return false"
                       oncopy="return false", 
                       onpaste="return false"
                     }
                 )

and in jquery :

$("#txtQuestion").on("cut copy paste",function(e) {

   e.preventDefault();
    // it will cause to stop default behaviour ofcommand
   // or we can use return false as well, as we did in js

}

 You can do it same way in asp.net web forms as well, for example:

<asp:TextBox ID="txtQuestion" 
             runat="server"
             CssClass="form-control"
             oncut="return false"
             oncopy="return false" 
             onpaste="return false">
</asp:TextBox>
Udemy

Difference between static and sealed class in c#

Saturday, June 13, 2015 0 Comments A+ a-


What is static class

A static class is very similar to non-static class, however there's one difference: a static class  can't be instantiated. In different words, you can not use the new keyword to make a variable of that class type. As a result of there's no instance variable, you access the static class members  by using class name. 

For Example,we have following static class which has a static method which adds two number.This is just as example, we already have a Math class in System namespace which framework has provided which has all the commonly used Math functions available:


public static class MathUtility
{
  public static int Add(int a, int b)
  {
   return a+b;
  }
}


We can call it this way:

 
int result = MathUtility.Add(2,5);


A static class will be used as a convenient instrumentation for sets of ways that simply treat input parameters and don't got to get or set any internal instance fields. for instance, in the .NET Framework class Library, the static System.Math class contains functions/methods that perform mathematical operations, with none demand to store or retrieve knowledge that's distinctive to a specific instance of the Math class. That is, you apply the members of the class by specifying the class name and also the methodology name, as shown within the following example.

 

double dub = -3.14;
Console.WriteLine(Math.Abs(dub));
Console.WriteLine(Math.Floor(dub));
Console.WriteLine(Math.Round(Math.Abs(dub)));

Output:

3.14

-4

3


As is that the case with all class types, the data for a static class is loaded by the .NET Framework common language runtime (CLR) once the program that references the class is loaded. The program cannot specifically tell when the class is loaded. However, it's certain to be loaded and to own its fields initialized and its static constructor referred to as before the class is documented for the primary time in your program. A static constructor is called just once, and a static class remains in memory for the time period of the applying domain during which your program resides.

Features of Static Class:

  1. It can only have static members.
  2. It cannot have instance members as static class instance cannot be created.
  3. It is a sealed class.
  4. As static class is sealed, so no class can inherit from a static class.
  5. we cannot create instance of static class that's the reason we cannot have instance members in static class, as static means shared so one copy of the class is shared to all.
  6. static class also cannot inherit from other classes.


What is sealed class


A sealed class cannot be inherited(means it cannot be used as a base class). It stops/restricts other classes from inheriting from it. Yes, when a class is marked sealed no other classes could inherit from it.

Consider the following example in which  class SealedClass inherited from class BaseClass but as we have marked SealedClass sealed using sealed modifier, it cannot be used as base class by other classes.

Consider the following example:

class BaseClass 
{

}    

sealed class SealedClass : BaseClass
{

}

We can also make methods and properties sealed. We can also mark overridden methods or properties  of base class in child class sealed so that they cannot be overridden further sub-classes that inherit from this subclass.

class A
{
 protected virtual void Foo()
 {
  Console.WriteLine("A.Foo");
 }

 protected virtual void Bar()
 {
  Console.WriteLine("A.Bar");
 }
}

class B : A
{
 sealed protected override void Foo()
 {
  Console.WriteLine("B.Foo");
 }

 protected override void Bar()
 {
  Console.WriteLine("B.Bar");
 }
}

Now see this :

class C : B
{
 // Attempting to override Foo causes compiler error CS0239. 
 // protected override void Foo() { Console.WriteLine("C.Foo"); }
 // Overriding F2 is allowed. 
 protected override void Bar()
 {
  Console.WriteLine("C.Bar");
 }
}

you cannot use abstract and sealed modifier together with a class because abstract class has to be inherited by some sub-class that gives implementation of  abstract methods/properties.

Also when using sealed modifier with methods/properties that method should be override.In .Net Framework structs are implicitly sealed which means they cannot be inherited.

Some run-time optimization are also done when sealed class members are called, so calling of  sealed class members is slightly faster than other.

The following are the points to keep in mind about sealed class:

  1. sealed class can be instantiated.
  2. It can inherit from other classes.
  3. It cannot be inherited
Udemy

User Friendly Display Text For Enum in C#

Wednesday, June 10, 2015 0 Comments A+ a-

When using Enum sometime we dont want to show the enum name that we have in code to user but instead of that we want to show some text that is understanable for end user.I will share today how we can set display text on Enum values that we can use to show to end-user.

Consider this Enum:


public enum eUserRole : int
 {
    SuperAdmin = 0,
    PhoenixAdmin = 1,
    OfficeAdmin = 2,
    ReportUser = 3,
    BillingUser = 4
  }





So, it is obvious that one would not like to show user SuperAdmin in this way without space, one would expect it to be displayed like "Super Admin" at front end.




For that first of all we will have to create a custom DisplayName attribute for Enum:





public class EnumDisplayNameAttribute : Attribute
{
  private string _displayName;
  public string DisplayName
  {
      get { return _displayName; }
      set { _displayName = value; }
  }
}





Now we can use this attribute to decorate it on our Enum values:







public enum eUserRole : int
{
    [EnumDisplayName(DisplayName="Super Admin")]
    SuperAdmin = 0,
    [EnumDisplayName(DisplayName = "Phoenix Admin")]
    PhoenixAdmin = 1,
    [EnumDisplayName(DisplayName = "Office Admin")]
    OfficeAdmin = 2,
    [EnumDisplayName(DisplayName = "Report User")]
    ReportUser = 3,
    [EnumDisplayName(DisplayName = "Billing User")]
    BillingUser = 4
}







For getting the DisplayName atttribute we have wrote an extension method on Enum which will return us the DisplayName attribute value:




















public static class EnumExtensions
{

   public static string DisplayName(this Enum value)
   {
       FieldInfo field = value.GetType().GetField(value.ToString());

       EnumDisplayNameAttribute attribute
               = Attribute.GetCustomAttribute(field, typeof(EnumDisplayNameAttribute))
                   as EnumDisplayNameAttribute;

       return attribute == null ? value.ToString() : attribute.DisplayName;
   }
}





and now we can call it on Enum values to get the DisplayName attribute value simply:







      Console.WriteLine(eUserRole.SuperAdmin.DisplayName());






This will output on Console:






           Super Admin 
















            

          

          

        

          

        




Udemy



OOP Difference between Shadowing and Overriding





Sunday, June 07, 2015


0 Comments A+
a-







Introduction: 

In this post, we will discuss the concept of Shadowing in OOP using c# and we will see how it works which will give you some idea that where we can use it and hopefully you will be able to decide when working practically in c# where it can be useful.



What is Shadowing:

Shadowing is a concept of  OOP (Object Oriented Programming) paradigm. Using Shadowing we can  provide a new implementation to base class member without overriding it, which means that original implementation of base class member gets shadowed (hidden) with the new implementation of base class member provided in derived class.



Consider a scenario where you have an external assembly which you have added in your project. You have a class in that assembly and it has a method which is not defined as virtual and you want to override that method(define your own implementation for that method) in the derived class. What would you do?

This is the scenario where you can use shadowing concept to override the method in the derived class



Definition:

 Following are few definitions of it





 According to MSDN:








    

  • Shadowing is concept of using Polymorphism in Object Oriented Programming. When two programming elements share the same name, one of them can hide, or shadow, the other one. In such a situation, the shadowed element is not available for reference; instead, when your code uses the element name, the compiler resolves it to the shadowing element.  
    • 

  •  Shadowing is actually hiding overridden method implementation in derived class and call the parent call implementation using derived class object
    • 










Difference between Overriding and Shadowing 



There is a major difference in shadowing and overriding which is 
normally when we override a virtual method in derived class and create 
instance of derived class and then if we hold reference to derived class
 object as base class object, and call that member, it always calls derived class implementation which is supposed to happen, but in 
shadowing the case is different, if for the same virtual member we 
shadow it in the derived class using new keyword and we call the 
implementation as above it will call base class implementation when we 
have reference to object of type base class and if we have reference to 
same object of derived type it will call derived type implementation so 
base class and derived class implementation are hidden from each other, 
method of which implementation to be called depends upon we are calling 
the member using reference of base type or derived type.



Example:



Suppose, I have a base class BaseLogger which has two virtual methods(means they can be overridden in subclass) defined:






public abstract class BaseLogger
{
    public virtual void Log(string message)
    {
        Console.WriteLine("Base: " + message);
    }

    public virtual void LogCompleted()
    {
        Console.WriteLine("Completed");
    }
}




Now i create a class Logger that inherits from BaseLogger class. Logger class looks like this:




public class Logger : BaseLogger
{
    public override void Log(string message)
    {
        Console.WriteLine(message);
    }

    public new void LogCompleted()
    {
        Console.WriteLine("Finished");
    }
}




Now i want my Console to Print following lines:



Log started!



Base: Log Continuing





Completed




What should i write in Main Program to get the above output ? Here is the code we will need to write:




public class Program
{
    public static void Main()
    {

        BaseLogger logger = new Logger();

        logger.Log("Log started!");
        logger.Log("Base: Log Continuing");
        logger.LogCompleted();
    }
}




The first call to Log method is OK, it has 
called Derived Logger class Log method and it should because we have 
overridden it in the Logger class.



The second call is also same.



Now note the third call, it has called  the base class LogCompleted() method not derived class, it is because we have defined derived class method with new keyword which is hiding the derived class method when we are calling it with object of type BaseLogger which is our base class.



If we want to call the derived class LogCompleted() method our object reference should be of type Logger not BaseLogger.While in method overriding this is not the case.



In
 method overriding if we cast object of derived class to base  class and
 call method, it will call overridden implementation of derived class.




















        

      













Subscribe to:
Posts (Atom)