C# Partial Classes and Methods

One of the unique features of C# is the concept of Partial, extendable to definition of a Class or a Struct, an Interface or a method.
Using this, the definition of any class, struct, interface of method can exist in 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.

To split a class definition, partial keyword modifier is used.

For Example:

   1:  publicpartialclass Pradeep

   2:      {

   3:  publicvoid OnLeave()

   4:          {

   5:          }

   6:      }

   7:   

   8:  publicpartialclass Pradeep

   9:      {

  10:  publicvoid InMeeting()

  11:          {

  12:          }

  13:      }

Here, it is valid to use the same name for the class and implement desired functionality separately.
Finally, when compiled, the code is auto merged , giving a Final class named Pradeep, with the two methods that were defined separately.

The partial keyword indicates that other parts of the class, struct, or interface can be defined in the namespace.
Following are the points that need to be taken care of while working with Partial keyword.

• All the parts must use the partial keyword.

• All the parts must have the same accessibility, such as public, private, and so on.

• All partial-type definitions meant to be parts of the same type must be defined in the same assembly and the same module (.exe or .dll file). Partial definitions cannot span multiple modules.

• If any part is declared abstract, then the whole type is considered abstract.

• If any part is declared sealed, then the whole type is considered sealed.

• If any part declares a base type, then the whole type inherits that class.

• Parts can specify different base interfaces, and the final type implements all the interfaces listed by all the partial declarations.

• Nested types can be partial, even if the type they are nested within is not partial itself

For Example:

class LeaveReachTimings
    {partialclass Residence
        {void TimetoReach() { }
        }partialclass Office
        {void TimeToLeave() { }
        }
    }

Here the Class LeaveReachTimings is not partial, but it is completely valid to declare partial classes Residence and Office as nested classes in it.

• Attributes of partial-type definitions are merged

For Example

    [SerializableAttribute]partialclass CurrentCompany { }

    [Obsolete Attribute]
    partialclass CurrentCompany { }

    These two attributes will finally merge and are equivalent to the following.

    [SerializableAttribute]
    [Obsolete Attribute]
    partialclass CurrentCompany { }

Enough of Theory Let us now create one partial Class to verify the concepts covered so far.

publicpartialclass Record
    {privateint x;privateint y;public Record(int x, int y)
        {this.x = x;this.y = y;
        }
    }publicpartialclass Record
    {publicint PrintSum()
        {return x + y;
        }

    }

Similar to Partial Classes, Partial Methods are also allowed. These are allowed in partial classes or struct.
One part of class contains the signature and the same or other part of the partial class can contain its implementation.
If no implementation is provided, then the method and all calls made to it are removed at compile time.

Therefore, any code in the partial class can use a partial method, even if the implementation is not supplied. No compile-time or run-time errors will result if the method is called but not implemented.

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.

Following are the considerations with Partial Methods.

• Partial method declarations must begin with the partial keyword

• Return Type is always void.

• out parameters are not allowed , however ref can be used.

• Partial methods cannot be virtual as they are implicitly private.

It means they have access modifiers such as public, private or internal. Hence, they cannot be called from outside the partial class, and cannot be declared as virtual.

• Partial methods cannot be extern, because the presence of the body determines whether they are defining or implementing.

• Partial methods can use static and unsafe modifiers.

• Partial methods can be generic.

• A delegate to a partial method which has an implementation, can be made. But, the partial method which has just a signature and no implementation can not have a delegate.

Example:

publicpartialclass PartialClassTest
    {privatestring mytest = string.Empty;partialvoid MyPartialMethodTest();

    }


    publicpartialclass PartialClassTest
    {partialvoid MyPartialMethodTest()
        {
            mytest = "Partial Method call Succeded!!";

        }

        publicstring returnstring()
        {
            MyPartialMethodTest();return mytest;

        }
    }

Here the partial methods, always return void and to get the value of mytest string I have to declare yet another method(return string), which finally prints the string on the webpage if called as per the following code.

protectedvoid Page_Load(object sender, EventArgs e)
    {
        PartialClassTest ptest = new PartialClassTest();
        Response.Write(ptest.returnstring());
    }

Please note: Delegate or Enumeration declarations can not use partial keyword.

Hope this discussion was helpful.

Till Next time we connect, Happy Coding!!!