Complete Syntax of a NON-GENERIC Class in C# with examples

To

Sam Hobbs,

Prasad Raveendran,

Muhammad Imran Ansari,

Muhammad Tahir Ansari

-------------------------------------

Thank you all for your guidence with vivid examples.

I have understood the way to implement class level parameters.

I am going to store these answers. 

With Kind Regards,

Dilip Nagle

e.&o.e.

In both examples of code there is a comma at the end. I am not aware of any syntax for classes where there would be a comma there. For interfaces a comma is used to separate bases but C# classes do not support multiple bases.

The question asks about non-generic classes therefore the following applies to non-generic classes.

The following is the C# Reference for classes.

https://learn.microsoft.com/en-us/dotnet/csharp/language-reference/keywords/class

That is definitely sparse. Half a century ago I read IBM manuals. IBM language references are much more complete. I am constantly disappointed by Microsoft documentation. At the bottomn of that page, however,  is a link to:

https://learn.microsoft.com/en-us/dotnet/csharp/language-reference/language-specification/readme

In that is:

https://learn.microsoft.com/en-us/dotnet/csharp/language-reference/language-specification/classes

That is the official specifications showing the exciting details and very many boring details. It is the documentation that a developer of a C# compiler needs to know to accurately recognize C# syntax and semantics. There the complete syntax is:

class_declaration
    : attributes? class_modifier* 'partial'? 'class' identifier
        type_parameter_list? class_base? type_parameter_constraints_clause*
        class_body ';'?
    ;

Note that there is a precise definition of the syntax used for specifying the syntax of the language; the syntax is not C#. And the precise details of all of that (such as attributes and class_modifiers) is provided.

Hello @Muhammad Imran Ansari:  There is a feature called Primary Constructor in C# 12. I would request you to take a look
https://learn.microsoft.com/en-us/dotnet/csharp/whats-new/tutorials/primary-constructors

In your above code, constructor parameters should be defined within a constructor, not in the class declaration itself.

// Not Like this:
public class ManagerData(int intyyyymmdd_Minbirthdate, string strEdunQuali_MinBE) : EmployeeData

// Should be like:
public class ManagerData : EmployeeData
{
    // Constructor with parameters
    public ManagerData(int intyyyymmdd_Minbirthdate, string strEdunQuali_MinBE)
    {
        // Initialize ManagerData properties or fields here if needed
    }

    // Additional properties and methods specific to ManagerData can be added here
}

As per your question, In C#, class-level parameters typically refer to class-level fields or properties that store values accessible to all instances of the class. These parameters can be used to configure or customize the behavior of class instances, and they are not specific to any particular instance. They are shared among all instances of the class.

public class MyClass
{
    // Class-level parameter as a field
    private int classLevelParameter;

    // Constructor to initialize the field
    public MyClass(int parameterValue)
    {
        classLevelParameter = parameterValue;
    }

    // Method that uses the class-level parameter
    public void PrintParameter()
    {
        Console.WriteLine("Class-level parameter: " + classLevelParameter);
    }
}

You might need Class-Level parameters:
1. Class-level parameters can be used to store configuration settings or constants that are shared among all instances of the class (connection string etc)
2. In some cases, you may want to maintain shared state or counters across instances
3. Class-level parameters can be used to define global constants or default values for the class.
4. They can be used for performance optimization by caching and reusing data or objects that should be shared among instances

In C#, a non-generic class is a class that doesn't have type parameters. Let me break down this definition for better understanding:

1. Class: A class is a blueprint for creating objects in object-oriented programming. It defines the structure and behavior of objects that can be created based on that class.

2. Generic Class: C# allows you to define classes with type parameters, which are often referred to as "generic classes." These type parameters allow you to create classes that can work with different data types without specifying them in advance.

3. Type Parameters: Type parameters are placeholders for data types. They allow you to create classes, methods, or structures that can work with different data types without specifying the data types until you use them. For example, List in C# is a generic class, and T is a type parameter that represents the type of elements the list can hold.

4. Non-Generic Class: A non-generic class, on the other hand, is a class that does not have type parameters. It is a class where the data types of its fields, properties, and methods are fixed and do not depend on any placeholder or generic type.

Here's an example to illustrate the difference:

// Generic Class with Type Parameter
public class MyGenericClass
{
    public T MyProperty { get; set; }
}

// Non-Generic Class
public class MyNonGenericClass
{
    public int MyProperty { get; set; }
}

In the example above, MyGenericClass is a generic class that can work with different data types (T is a type parameter). In contrast, MyNonGenericClass is a non-generic class with a fixed data type (in this case, int) for its property MyProperty.

So, in summary, a non-generic class is a class that doesn't have type parameters, and its members (fields, properties, methods) work with specific, predetermined data types.

Use Case: Geometric Shapes

Suppose you are modeling different geometric shapes like circles and rectangles in your application. You want to create a hierarchy of shape classes, with a base non-generic class Shape and derived classes Circle and Rectangle.

using System;

// Base non-generic class
public class Shape
{
    // Fields for common properties
    protected double width;
    protected double height;

    public Shape(double width, double height)
    {
        this.width = width;
        this.height = height;
    }

    public virtual double CalculateArea()
    {
        return 0.0; // Default implementation for area calculation
    }

    public virtual void DisplayInfo()
    {
        Console.WriteLine($"Shape: {GetType().Name}");
        Console.WriteLine($"Width: {width}");
        Console.WriteLine($"Height: {height}");
    }
}

// Derived class for Circle
public class Circle : Shape
{
    public Circle(double radius) : base(radius, radius)
    {
    }

    public override double CalculateArea()
    {
        return Math.PI * width * width;
    }
}

// Derived class for Rectangle
public class Rectangle : Shape
{
    public Rectangle(double width, double height) : base(width, height)
    {
    }

    public override double CalculateArea()
    {
        return width * height;
    }
}

In this example:

• The Shape class is a non-generic base class that represents a generic geometric shape. It has fields for common properties like width and height, a constructor to set these properties, and methods for calculating the area and displaying information about the shape. The virtual keyword is used to allow derived classes to override these methods.

• The Circle class is a derived class from Shape. It overrides the CalculateArea method to provide a specific implementation for calculating the area of a circle.

• The Rectangle class is another derived class from Shape. It also overrides the CalculateArea method to provide a specific implementation for calculating the area of a rectangle.

Here's how you can use these classes:

class Program
{
    static void Main()
    {
        Circle circle = new Circle(5.0);
        Rectangle rectangle = new Rectangle(4.0, 6.0);

        circle.DisplayInfo();
        Console.WriteLine($"Area of Circle: {circle.CalculateArea()}");
        
        Console.WriteLine();

        rectangle.DisplayInfo();
        Console.WriteLine($"Area of Rectangle: {rectangle.CalculateArea()}");
    }
}

This code demonstrates how you can create instances of the Circle and Rectangle classes, call their methods, and use inheritance to share common properties and behaviors through the non-generic base class Shape.

public class ManagerData(int intyyyymmdd_Minbirthdate, string strEdunQuali_MinBE) : EmployeeData
{
    public int Intyyyymmdd_Minbirthdate { get; }
    public string StrEdunQuali_MinBE { get; }

    public ManagerData(int intyyyymmdd_Birthdate, string strEdunQuali, int intEmployeeID)
    : base(intEmployeeID)
    {
        Intyyyymmdd_Birthdate = intyyyymmdd_Birthdate;
        StrEdunQuali = strEdunQuali;

        if (Intyyyymmdd_Birthdate < intyyyymmdd_Minbirthdate)
        {
            throw new Exception("Manager must be at least 18 years old.");
        }

        if (StrEdunQuali != strEdunQuali_MinBE)
        {
            throw new Exception("Manager must have a Bachelor's degree.");
        }
    }
}

In this example, the ManagerData class has two class-level parameters: intyyyymmdd_Minbirthdate and strEdunQuali_MinBE. These parameters are used to enforce the following business rules:

All managers must be at least 18 years old.

All managers must have a Bachelor's degr

ee.

To create a new ManagerData object, you must pass in values for the intyyyymmdd_Minbirthdate and strEdunQuali_MinBE parameters. If the values you pass in do not meet the business rules, the constructor will throw an exception.

Class-level parameters are a new feature that is still under development, but they have the potential to make your code more robust, reusable, and generic.

Class-level parameters are a new feature in C# 11 that is currently in preview. This means that it is not yet available in the stable version of C#.

The preview version of C# 11 is available in Visual Studio 2022 Preview and .NET 7.0 Preview. To use class-level parameters, you must create a new project and select the .NET 7.0 Preview framework.