C# Partial Types

C# provides a concept to write source code in separate files and compile it as a single unit. This feature is called partial types and included in C# 2.0. The partial keyword is used to create partial types.

It allows us to write partial class, interface, struct and method in two or more separate source files. All parts are combined when the application is compiled.

Let's see an example. Here, we are creating a partial class that includes a depositeAmount() function in the Customer.cs file and a withdraw() function in the Customer2.cs file. Both functions are stored in separate file and combined when compiled.

C# Partial Class Example

// Customer.cs
  1. using System;  
  2. namespace CSharpFeatures  
  3. {  
  4.    partial class Customer  
  5.     {  
  6.         // Deposit function  
  7.         public void depositAmount(int d_amount)  
  8.         {  
  9.             amount += d_amount;  
  10.             Console.WriteLine(d_amount+" amount is deposited");  
  11.             Console.WriteLine("Available balance is: "+amount);  
  12.         }  
  13.     }  
  14. }  

// Customer2.cs

  1. using System;  
  2. namespace CSharpFeatures  
  3. {  
  4.     partial class Customer  
  5.     {  
  6.         private int amount;  
  7.         public int Amount { get => amount; set => amount = value; }  
  8.         // Withdraw function  
  9.         public void withdraw(int w_amount)  
  10.         {  
  11.             amount -= w_amount;  
  12.             Console.WriteLine(w_amount+" is withdrawn");  
  13.             Console.WriteLine("Available balance is: "+amount);  
  14.         }  
  15.     }  
  16. }  
  1. using System;  
  2. namespace CSharpFeatures  
  3. {  
  4.     class Program  
  5.     {  
  6.         static void Main(string[] args)  
  7.         {  
  8.             Customer customer = new Customer();  
  9.             customer.Amount = 2000;  
  10.             Console.WriteLine("Current balance is: "+ customer.Amount);  
  11.             customer.depositAmount(1000);  
  12.             // Accessing seperate file function  
  13.             customer.withdraw(500);  
  14.         }  
  15.     }  
  16. }  

Output:

Current balance is: 2000
amount is deposited
Available balance is: 3000
500 is withdrawn
Available balance is: 2500

Why?

Partial classes provide a way to split the code of a class across files.

This way one file can contain generated code and another file could contain handwritten code. The generated code can than be regenerated without messing with the handwritten code. Had the custom code been added to the same file as the generated code, the regeneration would have overwritten it.

Visual Studio itself uses this in many places where designers generate code and users add logic. Sometimes Visual studio hides the generated code by only generating it during compilation (Compiling WPF applications generates a 'bridge' class between Xaml and 'code behind') and sometimes generated code is put in partial classes without providing an empty twin class which is left to the developer.

In general: when generating code use partial classes as a service to the developers that use the generator. And while we are at it: consider providing partial methods as well to allow the developer to hook in to the logic of the generated code so the developer is free to choose between implementing the partial method or sub classing the generated class for the correct reasons.


Database fist approach will generate model classes which are by default partial.

Comments

Post a Comment

Popular posts from this blog

C# | Association, Aggregation and Composition

Image
Association, Aggregation, and Composition are terms that represent relationships among objects. They are very basic stuff of Object-Oriented Programming. Association Association is a relationship among the objects. Association is "*a*" relationship among objects. In Association, the relationship among the objects determines what an object instance can cause another to perform an action on its behalf. We can also say that an association defines the multiplicity among the objects. We can define a one-to-one, one-to-many, many-to-one and many-to-many relationship among objects. Association is a more general term to define a relationship among objects. Association means that an object "uses" another object. For example, Managers and Employees, multiple employees may be associated with a single manager and a single employee may be associated with multiple managers. Aggregation Aggregation is a special type of Association. Aggregation is "*the*" relationship amo...
Read more

Throw vs Throw ex in C#

In C#, the   "throw"   keyword is used to throw an exception when an error occurs in your code. However, there are two variations of the   "throw"   statement:   "throw"   and   "throw ex" . We will look at the distinctions between   "throw"   and   "throw ex"   in C# in this article. In C#, the  "throw"  keyword is used to declare an exception. When an exception is thrown, the code that can handle it uses a catch block to capture it. The  "throw"  keyword is typically used to throw a new exception object, which can be created using the  "new"  keyword. For example, look at the below code: C# Code: try    {        // Some code that could potentially throw an exception    }   catch  (Exception ex)   {        // Handle the exception  ...
Read more

String[] args in C#

String[] args is a parameter of the Main method that represents the command-line arguments passed to the application when it is executed1. For example, if you run your application like this: MyApp.exe arg1 arg2 arg3 The args array will contain three strings: "arg1", "arg2", and "arg3". You can use the args array to access the command-line arguments and perform different actions based on them. For example, you can write a program that copies a file from one location to another by passing the source and destination paths as arguments1. Here is a simple example of how to use String[] args in C#: public   class Program  {       static void Main(string[] args)     {          Console.WriteLine("Number of arguments: " + args.Length);          foreach (string arg in args)         {             Console.WriteLine("Argument: " + arg);       ...
Read more