Reflection

Rajesh Pillai — Fri, 12 Feb 2010 12:13:16 GMT

Reflection has always fascinated me. Here a small reusable API to invoke methods dynamically. This uses local caching for optimization and takes care of multithreading as well..

You can use this class in a dll or a webservice..... Pass this method the following parameters..

1. dllPath : The path to the dll.

2. className : The type to load dynamically

3. methodName : The method to invoke

4 pInput[] : The input parameters if any.

private static Hashtable AssemblyHash = new Hashtable(1024);
private static Hashtable TypeHash = new Hashtable(10*1024);

Enjoy Programming...

Tech Tips: C# 3.0 Partial Methods

Rajesh Pillai — Sat, 28 Nov 2009 06:11:04 GMT

c# 3.0 : Partial Method

You are all aware of “Partial Class” introduced in .net 2.0. Partial class is useful in situation where you need to split the definition of a class,
struct or an interface over two or more source files. Each source file contains a section of the type or method definition and all parts are
combined when the application is compiled.

There are several situations when splitting a class definition is desirable:

When working on large projects, spreading a class over separate files enables multiple programmers to work on it at the same time.

· When working with automatically generated source, code can be added to the class without having to recreate the source file. Visual Studio
uses this approach when it creates Windows Forms, Web service wrapper code, and so on. You can create code that uses these classes without
having to modify the file created by Visual Studio.

Partial Method (.net 3.0):

Partial methods are the code block which reside inside a partial type and gets executed only when it has definition. This gives us the extensibility
and if user wants to implement the rule, they can go ahead and define the body but if they do not want it will not. This improves the performance as
you are not loading/creating unwanted methods. Partial methods are especially useful as a way to customize generated code. They allow for a
method name and signature to be reserved, so that generated code can call the method but the developer can decide whether to implement the
method. Much like partial classes, partial methods enable code created by a code generator and code created by a human developer to work together
without run-time costs.

A partial method declaration consists of two parts: the definition, and the implementation. These may be in separate parts of a partial class, or in the
same part. If there is no implementation declaration, then the compiler optimizes away both the defining declaration and all calls to the method.

// Definition in file1.cs

partial void onNameChanged();

// Implementation in file2.cs

partial void onNameChanged()
{
// method body
}

Partial method declarations must begin with the contextual keyword partial and the method must return void.
Partial methods can have ref but not out parameters.
Partial methods are implicitly private, and therefore they cannot be virtual.
Partial methods cannot be extern, because the presence of the body determines whether they are defining or implementing.
Partial methods can have static and unsafe modifiers.
Partial methods can be generic. Constraints are put on the defining partial method declaration, and may optionally be repeated on the implementing one. Parameter and type parameter names do not have to be the same in the implementing declaration as in the defining one.
You can make a delegate to a partial method that has been defined and implemented, but not to a partial method that has only been defined.

The above knowledge may seem very miniscule but it opens up a whole new opportunity when you are designing your system.
For e.g. Microsoft Entity Framework uses this feature for notifying property changes.

But beware there are caveats to it.

How can this knowledge be applied? Say for e.g. you have a class called “Address” which is declared as follows

public partial class Address
{
      private string city;
      public string City
    {
             get { return this.city;}
             set
             {
                     // If this method is implemented then the actual code will be executed else this will be ignored.
                     this.OnCityChanging(value);     // This is partial method. No exception will be thrown if this method is not implemented.

this.city = value;

             }
      }

    partial void OnCityChanging (string city);
}

public partial class Address
{
      partial void OnCityChanging(string city)
      {
                // You can add business rules/validation or constraints here…
               If (city == “prohibited city”)
                      throw new InvalidArgumentException(“This city is not allowed”);
      }
}

Create an instance of Address…

Address add = new Address();
add.City = “prohibited city”; // exception will be thrown.

This is just a rudimentary example to wet up your appetite. Now, wear your “Thinking Hat” and ponder over when you get some time
as to where this can be applied.

Reference:

http://msdn.microsoft.com/en-us/library/wa80x488.aspx

http://community.bartdesmet.net/blogs/bart/archive/2007/07/28/c-3-0-partial-methods-what-why-and-how.aspx