Today in this article, we will learn about C# .NET MySQL OPTIMIZE all tables. We will also see how to get all tables listed from MySQL and optimize each table programmatically using C#.NET.

As a developer or DBA (Database administrator) or tester, it’s important of validating the schema your database supports which includes all the tables and their structure.

Today, in this article, we will discuss below aspects,

Getting a list of tables in a database is a most useful query that most developers use.

Getting started

Create any .NET or .NET Core application. To keep it simple I shall be using the Console application however you can use any project template.

Add NuGet package – MySqlConnector

Please install the MySqlConnector Nuget package using Nuget Package Manager,

PM> NuGet\Install-Package Microsoft.Extensions.Configuration -Version 6.0.1

And

PM> NuGet\Install-Package MySqlConnector -Version 2.1.13

OR using .NET CLI

dotnet add package Microsoft.Extensions.Configuration --version 6.0.1

and

dotnet add package MySqlConnector --version 2.1.13

Command

Let us validate the with the most basic command as below. The following query will show all tables in a MySQL database:

SHOW TABLES;

Once you know the table to be optimized, use the below query to optimize the same

OPTIMIZE TABLE {table} 

If you have multiple tables to be optimized, you can specify the table list as below,

OPTIMIZE TABLE { table1, table2, table3 }

Below is a sample C# query supporting the show tables,

MySqlCommand cmd = new MySqlCommand($"OPTIMIZE TABLE {table}", connection);

Optimizing the table using C# .NET Code

Optimizing the given table using C# .NET Code can be achieved as below,

Sample code,

        try
            {
                connection.ConnectionString = con2;
                connection.Open();
                MySqlCommand cmd = new MySqlCommand($"OPTIMIZE TABLE {table}", connection);
                    cmd.ExecuteNonQuery();
                }
            }

            catch (Exception ex)
            {
                
            }

            connection.Close();

Where table is the table name to be optimized.

Optimizing All Tables using C# .NET Code

If you’re interested to optimize all the tables in the given database using C# .NET Code then please see the below code to achieve the same.

try
            {
                connection.ConnectionString = con2;
                connection.Open();
                string cmdStr = "show tables";
                TableNames = MySqlTableCollections(connection, cmdStr);

                foreach (string table in TableNames)
                {
                    MySqlCommand cmd = new MySqlCommand($"OPTIMIZE TABLE {table}", connection);
                    cmd.ExecuteNonQuery();
                }
            }

            catch (Exception ex)
            {
                
            }
            connection.Close();

MySqlTableCollections method logic is defined as below,

Do you have any comments or ideas or any better suggestions to share?

Please sound off your comments below.

Happy Coding !!

Please bookmark this page and share it with your friends. Please Subscribe to the blog to receive notifications on freshly published (2025) best practices and guidelines for software design and development.

The post C# .NET MySQL Optimize All Tables – Guidelines first appeared on TheCodeBuzz.

Today in this article we shall see the simple and easy approach of How to perform File Lock and Unlock in C# .NET when using it for reading or writing aka performing an update.

The discussed approach is very useful while dealing with any size of the file (.TXT or .CSV or .XLSX) where you need a temporary lock on a file so that other resources can not use it. This could be a legitimate use case for many requirements. It’s also important to write to file in a thread-safe manner.

In this article, we will cover when there is a need to lock files at the time of reading the data and when writing the data to a file.

Today in this article, we will cover below aspects,

For demonstration purposes, I have used a very simple example here.

Let’s say I have a Text file that I am creating using some process. I want this file to be locked until the file generation is completed is done.

Below is simple logic which reads the file.

Lock a file while reading the file data – Approach 1

If you would lock a file while reading a file then it is pretty simple to open a file and perform read operations using the below code as explained.

In the below code, we are reading the file using the FileStream Open method which lets you open FileStream on the specified path, with the specified mode.

Setting up FileShare.None will perform below,

• Declines sharing of the current file.
• Any request to open the file will fail until the file is closed.

Let’s see below complete example,

 private static void ReadFile(string filePath)
        {
            const int MAX_BUFFER = 1048576; //1MB 
            byte[] buffer = new byte[MAX_BUFFER];
            int bytesRead;
            int noOfFiles = 0;
            using (FileStream fs = File.Open(filePath, FileMode.Open, FileAccess.Read, FileShare.None))
            using (BufferedStream bs = new BufferedStream(fs))
            {
                while ((bytesRead = bs.Read(buffer, 0, MAX_BUFFER)) != 0) //reading 1mb chunks at a time
                {
                    noOfFiles++;
                    //Let's create a small size file using the data. Or Pass this data for any further processing.

                    File.WriteAllBytes($"Test{noOfFiles}.txt", buffer);
                }
            }
        }

Lock a file while Reading/Writing the file data – Approach 2

Lock a file in C# using File.Lock() method . The lock method let you lock a file so another process cannot access the file. This works even if it has read/write access to the file.

You can lock a file while reading the below simple code,

//Good
using (FileStream stream = File.Open(filePath, FileMode.OpenOrCreate, FileAccess.ReadWrite, FileShare.ReadWrite))
            {
                stream.Lock(0, stream.Length);

                /// You logic here////
            }

In the above method, we can call File.Open to deal a file for reading or writing operations.

Here we are exclusively locking out other processes or threads from accessing the file while you are using it.

When you are done with your operations on the file, code goes out of “using” statements thereby closing any file handle open and releasing it for others to use your file.

Lock a file while Writing to File data – Thread safety – Approach 3

If you ever need to lock a file while writing the data, you can use the below logic to perform the same.

Below we are maintaining synchronization on the file using the lock.

 public class WiteToFileUsingLock
    {
        public string Filepath { get; set; }
        private static object lockerFile = new Object();

        public void WriteToFile(StringBuilder text)
        {
            lock (lockerFile)
            {
                using (FileStream file = new FileStream(Filepath, FileMode.Append, FileAccess.Write, FileShare.Read))
                using (StreamWriter writer = new StreamWriter(file, Encoding.Unicode))
                {
                    writer.Write(text.ToString());
                }
            }

        }
    }

Above Lock exclusively locks the section of code dealing with files until the stream is written to a file and closed.

References:

• Find Most Recent Files in Directory in C#.NET

That’s all! Happy coding!

Does this help you fix your issue?

Do you have any better solutions or suggestions? Please sound off your comments below.

Please bookmark this page and share it with your friends. Please Subscribe to the blog to receive notifications on freshly published (2025) best practices and guidelines for software design and development.

The post How to File Lock and Unlock in C# .NET first appeared on TheCodeBuzz.

Today in this article, we will learn the concept of Covariance and Contravariance in C# .NET.

Covariant and contravariant generic type parameters provide flexibility in assigning and using the types. For example, covariant-type parameters enable you to make assignments that look much like ordinary polymorphism. This defined relationship affects the code compilation and ultimately runtime resolution of our types.

Before we dive into the concept of Covariance and Contravariance, Let’s dive into what we already know about the basic OOPS concept. As we know with the OOPS concept C# already has a relationship defined for the object in the form of Inheritance, Polymorphism, and subtyping.

Today in this article, we will cover below aspects,

Natural OOPS principles – a Reminder for Complex type

Let’s try rewinding OOPS – Inheritance and Subtyping.

Let’s take a simple example as shown below,

public class Employee{ }


public class FullTimeEmployee: Employee{ }


public class ContractEmployee: Employee{ }

Let’s understand the above example:

• Inheritance – FullTimeEmployee and ContractEmployee inherit from the base class Employee.
• Subtyping – One can easily substitute Employee with FullTimeEmployee or ContractEmployee using subtyping principles. That means you are allowed to do the below,
  • If a method has an input parameter of the type Employee, you can pass an instance of ContractEmployee or FullTimeEmployee as input
  • If a method is declared to return an Employee, you can return a ContractEmployee or a FullTimeEmployee.
  • A subclass overrides a method in a base class, the compiler must check that the overriding method has the right type.

Covariance in Array

Let’s start by looking at what covariance means.

Let’s take an example of an Employee class above discussed using Arrays.

In C# (and . NET), variance is a relation between a type. If two types are given as Base and Derived then,

• The relationship can be defined between Base and Derived
• And base class remains higher on the relationship Base ≥ Derived

Let’s take the above example into consideration,

• Covariance relationship: FullTimeEmployee[] is an Employee[]

Here Employee[] ≥ FullTimeEmployee[]

So it defines the Covariance in Employee if the order of constructed type i.e FullTimeEmployee follows the order Base >Derived

• Contravariant relationship:Employee[] is FullTimeEmployee[]

Here it defines Contravariance as the order is reversed,

Here Employee[] <= FullTimeEmployee[]

So it defines the ContraCovariance in Employee if the order of constructed type i.e FullTimeEmployee.

• Invariant relationship : Employee[] is not FullTimeEmployee[] and FullTimeEmployee[] is not an Employee[]

Let’s now see how these defined relationships affect the code compilation and ultimately runtime resolution of our types.

In the above-explained relationship Covariance and Contravariant relationship is not type-safe. This unsafe behavior can be verified using the below code,

           //checking is an array of FullTimeEmployee

            FullTimeEmployee[] checking = { new FullTimeEmployee("001") };

            //accountCollection array of CheckingAccounts

            Employee[] accountCollection = checking;

            //Now accountCollection here is an Array of 
            //FullTimeEmployee but not safe as assigning 
            //ContractEmployee could result in exception 

            accountCollection[0] = new ContractEmployee("001");

In the above example, accountCollection is the collection of FullTimeEmployee. Being able to use FullTimeEmployee or ContractEmployee where Employee is expected shows that Arrays are Covariant.

Later accountCollection is assigned with ContractEmployee which compiles perfectly fine but results in an exception in the runtime. These two types are incompatible the assignment doesn’t work and throws the below error as expected.

“Attempted to access an element as a type incompatible with the array”

The above behavior can also be explained using the below simple example

            //fullTime is an array of FullTimeEmployee

            FullTimeEmployee[] fullTime = { new FullTimeEmployee("001") };

            //accountCollection array of FullTimeEmployees

            Employee[] accountCollection = fullTime;

            //Now accountCollection here is an Array of 
            //FullTimeEmployee but not safe as assigning 
            //ContractEmployee could result in exception 

            accountCollection[0] = new ContractEmployee("001");

In the above example, we get the same exception of ArrayTypeMisMatchException. there is always a type check to verify the runtime type of the definition of the elements of the array is greater or equal to the instance being assigned to the element.

In the above example, because the runtime type of the array is an array of strings, the first assignment of array elements is valid because string ≥ string and the second is invalid because string ≤ object.

Covariance and Contravariance  in Generics

Covariant and contravariant generics provide greater flexibility in assigning and using generic types. The Base type and Derived type relationship defined above already holds true for generics also.

The type parameter of the IEnumerable<T> interface is covariant. You can assign an instance of IEnumerable<Derived> to a variable of type IEnumerable<Base>.

Covariance in generic type implemented is using the out generic modifier:

A generic type definition Generic<T> is:

• Covariant in T if the relationship is defined as Generic<Base> ≥ Generic<Derived>.
• Contravariant in T if the ordering of the constructed types are reversed from the ordering of the generic type parameters: Generic<Base> ≤ Generic<Derived>.
• Invariant in T if neither of the above applies.

Below are a few rules for Covariance,

• A covariant type parameter can be used as the return type of a delegate, and contravariant type parameters can be used as parameter types.

• For an interface, covariant-type parameters can be used as the return types of the interface’s methods, and contravariant-type parameters can be used as the parameter types of the interface’s methods.

• A generic interface or generic delegate type can have both covariant and contravariant type parameters.

Starting with the .NET Framework 4, several other generic interfaces have covariant type parameters;

•  IQueryable<T>

• IGrouping<TKey, TElement>. 

All the type parameters of these interfaces are covariant, so the type parameters are used only for the return types of the members. 

public interface IEnumerable<out T>
{
    IEnumerator<T> GetEnumerator();
}

public interface IEnumerator<out T>
{
    T Current { get; }
    bool MoveNext();
}

Please note the IEnumerable interface is marked as covariant using the out annotation.

Contravariance is enforced in relation to a particular generic type using the in-generic modifier,

.NET Framework 4+ onwards, several other generic interfaces have contravariant type parameters; for example: 

• IComparer<T>, IComparable<T>
• IEqualityComparer<T>

public interface IComparer<in T>
{
    int Compare(T x, T y);
}

These interfaces have only contravariant type parameters, so in the members of the interfaces, the type parameters are used only as parameter types.

Covariance and Contravariance  in Generics Delegates

.NET Framework 4+ onwards, the Func generic delegates are defined as below,

• Func<T, TResult>– have covariant return types and contravariant parameter types.
• Action<T1, T2>– The Action generic delegates, have contravariant parameter types.

The above indicates that delegates can be assigned to variables that have more derived parameter types and (in the case of the Func generic delegates) less derived return types.

class Employee { }

    class FullTimeEmployee : Employee { }

    class Program
    {
        
        public delegate Employee HandlerMethod();

        public static Employee AccountHandler()
        {
            return null;
        }

        public static FullTimeEmployee CheckinghHandler()
        {
            return null;
        }

        static void CovarianceTest()
        {
            HandlerMethod handlerMammals = AccountHandler;

            // Covariance is valid here for below assignment 
            HandlerMethod handlerDogs = CheckinghHandler;
        }
    }

Example Contravariance:

In the below example, we shall see with contravariance, you can use one event handler instead of separate handlers and demonstrate delegate’s use with methods that have parameters (whose types are base type of delegate signature parameters).

public delegate void KeyEventHandler(object sender, KeyEventArgs e)

public delegate void MouseEventHandler(object sender, MouseEventArgs e)

public partial class Form1 : Form
    {
        public Form1()
        {
            InitializeComponent();

            // Use a method that has an EventArgs (Although the event expects the KeyEventArgs).  
            this.button1.KeyDown += this.MultiHandler;

            // Use the same method expects the MouseEventArgs parameter.  
            this.button1.MouseClick += this.MultiHandler;
        }

        // Event handler that accepts a parameter of the EventArgs type.  
        private void MultiHandler(object sender, System.EventArgs e)
        {
            label1.Text = System.DateTime.Now.ToString();
        }
    }

Do you have any comments or ideas or any better suggestions to share?

Please sound off your comments below.

Happy Coding !!

Please bookmark this page and share it with your friends. Please Subscribe to the blog to receive notifications on freshly published (2025) best practices and guidelines for software design and development.

The post Covariance and Contravariance in C# .NET first appeared on TheCodeBuzz.

Today in this article, we shall see how to get File’s Last Modified or Last Written date in C# application code.

Today in this article, we will cover below aspects,

Get Files last Modified date or Last Written date

    DateTime modifyTime = File.GetLastWriteTime(@"file-input-thecodebuzz.txt");

Get Files created Date date

    DateTime creationTime= File.GetCreationTime(@"file-input-thecodebuzz.txt");

As per Microsoft gudelines,

This method may return an inaccurate value, because it uses native functions whose values may not be continuously updated by the operating system. Each operating system manages the last write time according to its own rules. To improve performance, an operating system might not set the last write time value to the exact time of the last write operation, but might set it to a close approximation instead.

File GetLastWriteTime returns 1601

This method returns January 1, 1601 A.D. (C.E.) Coordinated Universal Time (UTC) if the specified file doesn’t exist in the specified path.

Exceptions

You can handle any of the below exceptions,

• UnauthorizedAccessException
• ArgumentException
• PathTooLongException
• NotSupportedException

References:

• Unit Test and Mock File methods – Guidelines

Do you have any comments or ideas or any better suggestions to share?

Please sound off your comments below.

Happy Coding !!

Please bookmark this page and share it with your friends. Please Subscribe to the blog to receive notifications on freshly published (2025) best practices and guidelines for software design and development.

The post Get File’s Last Modified or Last Written date in C# first appeared on TheCodeBuzz.

Today in this article, we shall see returning Boolean Task from a Task-based method. Here we will return bool from task i.e true or false from task-based operation.

Today in this article, we will cover below aspects,

Using Task<TResult>  you can return boolean, int, or string depending on your requirements where the operand is TResult. Here declaration must specify a return type of Task<bool> or Task<int> as required.

Async methods that don’t contain a return statement usually have a return type of Task. If a method returns Task, that means it’s the asynchronous version of a void method.

Return Boolean from Task Asynchronously

Below an example for returning a boolean from Task asynchronously.

public async Task<bool> Delete(string key)
        {
            var isSuccess = false;
            try
            {
               await _cache.RemoveAsync(key);
                isSuccess = true;
            }
            catch(Exception ex)
            {
                Console.WriteLine(ex.Message);
                return isSuccess;
            }

            return true;
        }

Return Bool (True or False) from Task Synchronously

To return Boolean from Task Synchronously, we can use Task.FromResult<TResult>(TResult) Method. This method creates a Task result that’s completed successfully with the specified result.

The calling method uses an await operator to suspend the caller’s completion till called async method has finished successfully.

Example

public Task<bool> DeleteCache(string key)
        {
            var isSuccess = false;
            try
            {
                 _cache.Remove(key);
                isSuccess = true;
            }
            catch (Exception ex)
            {
                Console.WriteLine(ex.Message);
                return Task.FromResult(isSuccess);
            }

            return Task.FromResult(isSuccess); ;
        }

Here above you determine when to send true or false using Task.FromResult() for the operation based on the custom validation.

References :

• Multithreading Async and Await methods- Asynchronous Programming

Do you have any comments or ideas or any better suggestions to share?

Please sound off your comments below.

Happy Coding !!

Please bookmark this page and share it with your friends. Please Subscribe to the blog to receive notifications on freshly published (2025) best practices and guidelines for software design and development.

The post Returning Boolean Task from a Task first appeared on TheCodeBuzz.