When you assign a method to a delegate, covariance and contravariance provide flexibility for matching with method signature.
Covariance permits a method to have return type as more derived than that defined in the delegate.
Contravariance permits a method that has parameter types that are less derived than those in the delegate type.
function validate(evt) {
var theEvent = evt || window.event;
var key = theEvent.keyCode || theEvent.which;
key = String.fromCharCode(key);
var regex = /^[0-9a-zA-Z\s\b]+$/;
if (!regex.test(key)) {
theEvent.returnValue = false;
if (theEvent.preventDefault)
theEvent.preventDefault();
}
}
<asp:TextBox ID="txtVal" runat="server" onKeyPress="validate(e);"></asp:TextBox>
var re = /^-?\d+$/;
var matches = re.test(args.Value);
function isNumberKey(evt) {
var charCode = (evt.which) ? evt.which : event.keyCode
if (charCode > 31 && (charCode < 48 || charCode > 57))
return false;
return true;
}
static class MyExtensionMethods
{
public static int Negate(this int value)
{
return -value;
}
public static int Multiply(this int value, int multiplier)
{
return value * multiplier;
}
}
static void Main(string[] args)
{
// Passing arguments in extension methods
int i3 = 10;
Console.WriteLine(i3.Multiply(2));
}
| Stored Procedure | Function |
| Return type is not must, Can return zero, single or multiple values or table(s) | Return type is must, and it can return one value which is mandatory. UDFs that return tables can be treated as another rowset. This can be used in JOINs with other tables. |
| SP can have input/output parameters | Support only input parameters |
| Allow Select as well as DML statements. | Allow Select but not DML statements. Note: In case of multi-table valued functions it can contain DML statements affecting Table Variables. |
| Stored procedure can execute function. | Function cannot execute stored procedure. |
| Cannot be the part of Select query as a column. | Can be the part of select query as a column |
| Stored Procedures cannot be embedded in the SQL statements like WHERE/HAVING/SELECT | Functions can embedded in the SQL statements like WHERE/HAVING/SELECT |
| We can use exception handling using Try....Catch block in SP. | We can’t use Try....Catch block in UDF |
| We can use transactions in SP | We can’t user transaction in UDF |
| Can have up-to 21000 input parameters | UDF can have up-to 1023 input parameters |
Functions are computed values and cannot perform permanent environmental changes to SQL Server (i.e. no INSERT or UPDATE statements allowed). It returns error like “Invalid use of a side-effecting operator 'INSERT' within a function.” So ultimately strict rule is made by Sql team: we can't execute stored procedures inside function.
public class BaseClass
{
public string GetMethodOwnerName()
{
return "Base Class";
}
}
public class ChildClass : BaseClass
{
public new virtual string GetMethodOwnerName()
{
return "ChildClass";
}
}
public class SecondChild : ChildClass
{
public override string GetMethodOwnerName()
{
return "Second level Child";
}
}
static void Main(string[] args)
{
ChildClass c = new ChildClass();
Console.WriteLine(c.GetMethodOwnerName());
}static void Main(string[] args)
{
BaseClass c = new ChildClass();
Console.WriteLine(c.GetMethodOwnerName());
}While writing a code, we often come across situations where we need to return multiple values from a single function/method. But a method can only return a single value.The question is how do we overcome such situation.Answer is simple, use reference types.
Parameters are always passed by value to a method by default.If we want to pass them by reference then we can use either out or ref keyword.
Ref
The ref keyword is used to pass an argument as a reference. This means that when value of that parameter is changed in the method, it gets reflected in the calling method. An argument that is passed using a ref keyword must be initialized in the calling method before it is passed to the called method.
Ref keyword will pass parameter as a reference this means when the value of parameter is changed in called method it get reflected in calling method also. There is no "boxing" when a value type is passed by reference
Out
The out keyword is also used to pass an argument like ref keyword, but the argument can be passed without assigning any value to it. An argument that is passed using an out keyword must be initialized in the called method before it returns back to calling method.
Out keyword also will pass parameter as a reference but here out parameter must be initialized in called method before it return value to calling method
public ActionResult Index()
{
int val1 = 0; //must be initialized for ref
int val2 = 0; //optional for out
Example1(ref val1);
ViewBag.Message += val1 + "\n"; // val1=0
Example2(out val2);
ViewBag.Message += val2 + "\n"; // val1=2
return View();
}
static void Example1(ref int value) //called method
{
//value = 1; // optional
}
static void Example2(out int value) //called method
{
value = 2; //must to assign value
}
These ref and out parameters are useful whenever your method wants to return more than one value.
Both the method definition and the calling method must explicitly use the ref / out keyword
Several inbuilt methods as "TryParse" (one of my favourite) use out and not ref, may be the internal implementation of library mainly uses ref.
Properties/Indexers/Dynamic member access cannot be passed to ref or out parameters since internally they are functions/methods and not members/variables
ref tells the compiler that the object is initialized before entering the function, while out tells the compiler that the object will be initialized inside the function.
Ref and out in method overloading
Both ref and out cannot be used in method overloading simultaneously. However, ref and out are treated differently at run-time but they are treated same at compile time (CLR doesn't differentiates between the two while it created IL for ref and out). Hence methods cannot be overloaded when one method takes a ref parameter and other method takes an out parameter. The following two methods are identical in terms of compilation.
class MyClass
{
public void Method(out int a) // compiler error “cannot define overloaded”
{
// method that differ only on ref and out"
}
public void Method(ref int a)
{
// method that differ only on ref and out"
}
}
However, method overloading can be done, if one method takes a ref or out argument and the other method takes simple argument. The following example is perfectly valid to be overloaded.
class MyClass
{
public void Method(int a)
{
}
public void Method(out int a)
{
// method differ in signature.
}
}
public static void Foo()
{
int val = 0;
Example1(val);
Console.WriteLine(val); // Still 0!
Example2(ref val);
Console.WriteLine(val); // Now 2!
Example3(out val);
Console.WriteLine(val); // Now 3!
}
static void Example1(int value)
{
value = 1;
}
static void Example2(ref int value)
{
value = 2;
}
static void Example3(out int value)
{
value = 3;
}
| Ref | Out |
| The parameter or argument must be initialized first before it is passed to ref. | It is not compulsory to initialize a parameter or argument before it is passed to an out. |
| It is not required to assign or initialize the value of a parameter (which is passed by ref) before returning to the calling method. | A called method is required to assign or initialize a value of a parameter (which is passed to an out) before returning to the calling method. |
| Passing a parameter value by Ref is useful when the called method is also needed to modify the pass parameter. | Declaring a parameter to an out method is useful when multiple values need to be returned from a function or method. |
| It is not compulsory to assign a parameter value before leaving calling method. | A parameter value must be assigned within the calling method before its use. |
| When we use REF, data can be passed bi-directionally. | When we use OUT data is passed only in a unidirectional way (from the called method to the caller method). |
| Both ref and out are treated differently at run time and they are treated the same at compile time. | |
| Properties are not variables, therefore it cannot be passed as an out or ref parameter. | |
The out and ref keywords are useful when we want to return a value in the same variables as are passed as an argument
They are both the same functionally but the .min has all unnecessary characters (white-spaces and comments stripped out, shorter variable names, ...) removed in order to make the file size smaller.
Just to point out as well, you are better using the minified version (.min) for your live environment as Google are now checking on page loading times. Having all your JS file minified means they will load faster and will score you more brownie points.
public static class MyExtensions
{
static int WordCount(this String str, char[] charArray)
{
return str.Split(charArray).Length;
}
}
string str = "Hello Extension Methods";
int i = str.WordCount(new char[] { ' ', '.', '?' });
An extension method with the same name and signature in an interface or class method (1st priority) will never be called.
Inherit the class and then implement the functionality in an instance method in the derived class.
A university owns various departments (e.g., chemistry), and each department has a number of professors. If the university closes, the departments will no longer exist, but the professors in those departments will continue to exist. Therefore, a University can be seen as a composition of departments, whereas departments have an aggregation of professors. In addition, a Professor could work in more than one department, but a department could not be part of more than one university.
public interface IMyInterface
{
// Any class that implements IMyInterface must define a method
// that matches the following signature.
void MethodB();
}
public static class Extension
{
public static void MethodA(this IMyInterface myInterface, int i)
{
Console.WriteLine("Extension.MethodA");
}
}
public class A : IMyInterface
{
public void MethodB() { Console.WriteLine("A.MethodB()"); }
}
class ExtMethodDemo
{
static void Main(string[] args)
{
A a = new A();
a.MethodA(1); //A contains no MethodA,
//so it calls the extension method that has a matching signature.
}
}
Extension.MethodA
public class Class1
{
public string Display()
{
return ("Display");
}
public string Print()
{
return ("Print");
}
}
public static class XX
{
public static void NewMethod(this Class1 ob)
{
Console.WriteLine("NewMethod");
}
}
class Program
{
static void Main(string[] args)
{
Class1 ob = new Class1();
ob.Display();
ob.Print();
ob.NewMethod();
Console.ReadKey();
}
}
}
Display
NewMethod
The compiler doesn't cause an error if two extension methods with same name and signature are defined in two different namespaces and these namespaces are included in same class file using directives. Compiler will cause an error if you will try to call one of them extension method.
One of the great reasons for Extension methods is behind LINQ. Without extension methods a lot of what you can do in LINQ would be very hard. The Where(), Contains(), Select extension methods means a lot more functionality is added to existing types without changing their structure
The biggest disadvantage is that there's no compiler error or warning if you have a regular method and an extension method with the same signature in the same context.
Extension methods fit very well into an OOP design: consider the simple method
bool empty = String.IsNullOrEmpty (myString)bool empty = myString.IsNullOrEmpty ();
class Program
{
static void Main(string[] args)
{
List<Product> Products = new List<Product>()
{
new Product{ProductName = "White Shoe", ProductPrice = 10},
new Product{ProductName = "Green Shoe", ProductPrice = 5},
new Product{ProductName = "Black Shoe", ProductPrice = 15}
};
foreach (Product p in Products)
{
Console.WriteLine("{0} costs {1} (VAT: {2})",
p.ProductName, p.ProductPrice, p.CalculateVat());
}
}
}
public static class MyExtensions
{
public static double CalculateVat(this Product p)
{
return (p.ProductPrice * .25);
}
}
public class Product
{
public string ProductName { get; set; }
public double ProductPrice { get; set; }
}
However, you do not own or have control over the Product class since it is owned by someone else. So you can’t add a CalculateVat() method to the product class, And it can be done by using EXTENSION METHODS.
It is not compulsory to create delegates. It is just the easiest way in some situations to get the thing done.
If you have multiple methods with same signature (return type & number of parameters) and want to call all the methods with single object then using delegates is the best option.
C# delegates are similar to C++ function pointers and are type safe. A delegate is a reference type variable that holds the reference to a method. The reference can be changed at runtime.
All delegates are implicitly derived from the System.Delegate class. Delegates are especially used for implementing events and the call-back methods (Anonymous). Delegates allow methods to be passed as parameters. Delegate types are sealed and immutable type. Effective use of delegate improves the performance of application.
Whenever we want to create delegate methods we need to declare with delegate keyword. Delegate methods signature should match exactly with the methods signature (Parameter list) that Invokes.
public delegate int MyDelegate (string s);
The preceding delegate can be used to reference any method that has a single string parameter and returns an int type variable.
delegate <return type> <delegate-name> <parameter list>
Once a delegate type is declared, a delegate object must be created with the new keyword and be associated with a particular method. When creating a delegate, the argument passed to the new expression is written similar to a method call, but without the arguments to the method.
Following example demonstrates declaration, instantiation, and use of a delegate that can be used to reference methods that take an integer parameter and returns an integer value.
using System;
delegate int NumberChanger(int n);
namespace DelegateAppl
{
class TestDelegate
{
static int num = 10;
public static int AddNum(int p)
{
num += p;
return num;
}
public static int MultNum(int q)
{
num *= q;
return num;
}
public static int getNum()
{
return num;
}
static void Main(string[] args)
{
//create delegate instances
NumberChanger nc1 = new NumberChanger(AddNum);
NumberChanger nc2 = new NumberChanger(MultNum);
//calling the methods using the delegate objects
nc1(25);
Console.WriteLine("Value of Num: {0}", getNum());
nc2(5);
Console.WriteLine("Value of Num: {0}", getNum());
Console.ReadKey();
}
}
}
Value of Num: 35
Value of Num: 175
It is a delegate which holds the reference of more than one method. Delegates can be chained together; for example, multiple methods can be called on a single event
Delegate objects can be composed using the "+" operator. A composed delegate calls the two delegates it was composed from. Only delegates of the same type can be composed. The "-" operator can be used to remove a component delegate from a composed delegate.
Using this property of delegates you can create an invocation list of methods that will be called when a delegate is invoked. This is called multicasting of a delegate. The following program demonstrates multicasting of a delegate:
using System;
delegate int NumberChanger(int n);
namespace DelegateAppl
{
class TestDelegate
{
static int num = 10;
public static int AddNum(int p)
{
num += p;
return num;
}
public static int MultNum(int q)
{
num *= q;
return num;
}
public static int getNum()
{
return num;
}
static void Main(string[] args)
{
NumberChanger nc;
NumberChanger nc1 = new NumberChanger(AddNum);
NumberChanger nc2 = new NumberChanger(MultNum);
nc = nc1;
nc += nc2;
nc(5);//calling multicast
Console.WriteLine("Value of Num: {0}", getNum());
Console.ReadKey();
}
}
}
Value of Num: 75
The following example demonstrates the use of delegate. The delegate printString can be used to reference method that takes a string as input and returns nothing.
We use this delegate to call two methods, the first prints the string to the console, and the second one prints it to a file:
using System;
using System.IO;
namespace DelegateAppl
{
class PrintString
{
static FileStream fs;
static StreamWriter sw;
public delegate void printString(string s);
public static void WriteToScreen(string str)
{
Console.WriteLine("The String is: {0}", str);
}
public static void WriteToFile(string s)
{
fs = new FileStream("c:\\msg.txt",FileMode.Append, FileAccess.Write);
sw = new StreamWriter(fs);
sw.WriteLine(s);
sw.Flush();
sw.Close();
fs.Close();
}
static void Main(string[] args)
{
printString ps1 = new printString(WriteToScreen);
printString ps2 = new printString(WriteToFile);
ps1("Hello World");
ps2("Hello World");
Console.ReadKey();
}
}
}
The String is: Hello World
Generic Delegate was introduced in .NET 3.5 that don't require to define the delegate instance in order to invoke the methods.
The Func delegate defines a method that can be called on arguments and returns a result.
The Action delegate defines a method that can be called on arguments that returns void. In the given code example, delegate Action<string> is defined with string as argument.
Action<string> MyAction = y => Console.Write(y);
MyAction("Hello");
Console.ReadKey();
The Predicate delegate defines a method that can be called on arguments and always returns Boolean type result.
Name, Version, Architecture, Culture, Public Key.
Although the first 3 are generally the big ones.
1) Drag and Drop
2) Use GacUtil.exe with Visual Studio Command Prompt
gacutil -i [Path][Assembly Name].dll
Note: To install an assembly into the GAC, the assembly must be strongly named. Otherwise you get an error like this: Failure adding assembly to the cache: Attempt to install an assembly without a strong name.
gacutil -u [Assembly Name], Version=1.0.0.0, PublickeyToken=7896a3567gh
Note: has no extention, .dll. Version and PublickeyToken can be omitted and be checked in GAC assembly.
struct myStructure
{
string x = 2;//Not allowed
}
class myClass
{
string x = 2;//Allowed
}
MyClass obj1 =new MyClass ();
obj1.DataMember=10;
MyClass obj2 =obj1;
obj2.DataMember=20;
Public Int DataMember; //By default, accessibility of Structure data
//members will be private. So I am making it as
//Public which can be accessed out side of the structure.
MyStructure obj1 =new MyStructure ();
obj1.DataMember=10;
MyStructure obj2 =obj1;
obj2.DataMember=20;
struct Me
{ private Me()// compile-time error
{ } }
class Me
{ private Me()// runs Ok
{ } }