Code practise : Good and Bad

1. Follow naming conventions:

arduino
// Bad: 
int a;
int x1;

// Good: 
int age;
int numberOfCustomers;

2. Use comments:

arduino
// Bad: 
int result = 10 / 0; // Divide by zero

// Good: 
// Divide the dividend by the divisor and return the result.
// Throws DivideByZeroException if divisor is zero.
int Divide(int dividend, int divisor)
{
    if (divisor == 0)
    {
        throw new DivideByZeroException("Divisor cannot be zero.");
    }

    return dividend / divisor;
}

3. Keep your code clean and organized:

c
// Bad: 
int a=10,b=20,c=30,d=40;string name="John";

// Good: 
int a = 10;
int b = 20;
int c = 30;
int d = 40;

string name = "John";

4. Use exception handling:

arduino
// Bad: 
int result = 10 / 0; // throws DivideByZeroException and crashes the program

// Good: 
try
{
    int result = 10 / 0;
}
catch (DivideByZeroException ex)
{
    Console.WriteLine("Divide by zero error: " + ex.Message);
}

5. Use object-oriented programming principles:

csharp
// Bad: 
public int Add(int a, int b)
{
    return a + b;
}

// Good: 
public interface IAddable
{
    int Add(int a, int b);
}

public class Calculator : IAddable
{
    public int Add(int a, int b)
    {
        return a + b;
    }
}

6. Write efficient code:

scss
// Bad: 
for (int i = 0; i < myList.Count; i++)
{
    Console.WriteLine(myList[i]);
}

// Good: 
foreach (var item in myList)
{
    Console.WriteLine(item);
}

7. Test your code thoroughly:

csharp
// Bad: 
public int Add(int a, int b)
{
    return a + b;
}

// Good: 
[TestClass]
public class CalculatorTests
{
    [TestMethod]
    public void TestAdd()
    {
        Calculator calc = new Calculator();
        int result = calc.Add(2, 3);
        Assert.AreEqual(5, result);
    }
}

By following these coding practices, you can write clean, maintainable, and efficient C# code that is easy to read and understand, and that works as expected.

.Net core feature

ASP.NET Core is a cross-platform, open-source web framework developed by Microsoft that allows developers to build modern, high-performance web applications using a variety of programming languages, including C#, F#, and Visual Basic.

Here are some of the key features of ASP.NET Core:

1. Cross-platform: ASP.NET Core is designed to work on multiple operating systems, including Windows, macOS, and Linux. This allows developers to build and deploy web applications on a wide range of platforms.

2. High performance: ASP.NET Core is optimized for performance, with features such as just-in-time compilation and a lightweight runtime that help to improve application speed and scalability.

3. Modular design: ASP.NET Core has a modular design that allows developers to choose the components they need for their application, rather than being forced to use a monolithic framework. This makes it easier to build and maintain complex applications.

4. Open source: ASP.NET Core is open source, with a large and active community of developers contributing to its ongoing development and improvement.

5. Built-in dependency injection: ASP.NET Core includes a built-in dependency injection system, which makes it easier to manage dependencies and simplify application configuration.

6. Middleware pipeline: ASP.NET Core uses a middleware pipeline to process incoming HTTP requests and outgoing responses. This allows developers to easily add and remove middleware components, and to build custom middleware to handle specific application requirements.

7. Cloud-ready: ASP.NET Core is designed to work seamlessly with cloud platforms such as Azure, AWS, and Google Cloud. This makes it easier to deploy and scale applications in the cloud.

Overall, ASP.NET Core provides a powerful, flexible, and scalable framework for building modern web applications that can run on a wide range of platforms and devices. 

SQL server : WITH TIES

WITH TIES allows adding one or more rows along with the rows limited by the TOP or similar statements. It works only when you use it alongside the ORDER BY expression.

Table data:

Query result:

SPARSE Column in sql server

What is a SPARSE Column?

Sparse columns provide a highly efficient way of managing empty space in a database by enabling NULL data to consume no physical space. For example, sparse columns enable object models that typically contain numerous null values to be stored in a SQL Server 2008 database without experiencing large space costs.

What is a Column Set?

Tables that contain sparse columns can define a column set to return the data in all of the sparse columns in the table. Similarly to a computed column, it is not physically stored in the table; however, unlike computed columns, the data in it is directly editable. The column set returns an untyped XML representation of the data. Column sets are useful when you have a large number of sparse columns in a table and working with them is awkward.

How to use SQL Server Sparse Columns ?

We can define sparse columns by using either the CREATE TABLE or ALTER TABLE statement, using the SPARSE keyword for the columns that you require to be sparse columns. 

Notes :

Sparse columns require more storage space for non-null values than a standard column.

Data types like geography, geometry, image, ntext, text, and timestamp cannot be used for sparse columns. 

Example: