Today, in this article will see how to write a MongoDB Date query to get records based on timestamp or date range.

We can easily find the records between the two given dates. These queries are effective means to perform efficient searches.

We will cover the below aspects in today’s article,

We already looked at a simple way of adding or updating a new field to the document in our previous MongoDB sample series.

We shall see examples for the MongoDB Date Range filter including a date greater than or less than time or date assuming we already have a date-specific field in the database.

If you don’t have a date or any timestamp field in the document, you can still use another approach using _Id an ObjectID field to get the records between two dates.

Please visit the below article for the same,

• Query MongoDB using ObjectId by Date -MongoShell

Getting started

Here below is a sample schema or document we shall use for the date range query,

MongoDB Find objects between Two dates

Here we will be using the below query to get the documents between two dates in MongoDB Collection.

Mongo Date greater than query (‘gt’) – ISO Date

The below query gives us all the records matching the Date greater than the query

Command

{ <Field Name>: { $gt:ISODate('Date here') } }

 

Example

db.collection.find({ "DateAdded": { $gt: ISODate("2023-05-01T00:00:00Z") } })

MongoDB query date without timestamp

The below query gives us all the records using greater than the query with date only

Example

db.collection.find({ "DateAdded": { $gt: ISODate("2023-05-01") } })

MongoShell query

Mongo Date Less than query (‘$lt)

The below query gives us all the records using field value where it matches with the less than the given date.

Command

{ <Field Name>: { $lt:ISODate('Date here') } }

Example

db.collection.find({ "DateAdded": { $lt: ISODate("2023-05-01T00:00:00Z") } })

MongoDB query – For records between greater than ($gte) the date and less than ($lte) dates

The below query gives us all the records using field value where it matches with the less than and greater than the given date.

Command

{  <Field name> : { $gt:ISODate('Date Here'), $lt:ISODate('Date here')  }  }

Examples

db.collection.find({ DateAdded : { $gt:ISODate('2019-09-18T21:07:42.313+00:00')}, { $lt:ISODate('2020-09-18T21:07:42.313+00:00')}})

Mongo Atlas UI

Mongo shell

What if there is no Date field in Mongo Schema?

You may be wondering if there is a way to perform a search query based on a date even if there is no Date field in Mongo Schema.

It’s possible but with a few limitations.

Please visit the article for more details…

• How to find records in MongoDB without date fields?

What is the difference between $gt and $gte or $lt and $lte in MongoDB?

The above commands are very simple and easy to understand. There are small differences between these commands.

$gte

$gte  = greater than or equal to i.e > =

$gt

$gt  = greater than i.e > 

$lte

lte  = less than or equal to i.e < =

$lt

lt  = less than i.e < 

TIP – IF you need to use Data range query often then is recommanded to indexed the dates fields.

Other References

• How to find records in MongoDB without date fields?

• MongoDB Repository implementation in .NET Core with example

• MongoDB naming standards and convention

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 MongoDB Date query to get records between two dates first appeared on TheCodeBuzz.

Today in this article we will learn best practices for Async Await in C#.NET.

When working with asynchronous programming in .NET using the async and await keywords, it’s important to follow best practices to ensure efficient and maintainable code.

Here are some best practices for working with async and await in .NET.

Use async and await throughout the code workflow

To get the best out of your code workflow this is an important aspect.

Use must use async and await throughout your codebase consistently and without missing any place to get full execution of the asynchronous nature of method execution.

Any miss of calling method/services will make the method a blocking method causing synchronous code execution of code.

Apply async to methods that perform long-running or I/O-bound operations, and use await to asynchronously wait for the results of those operations.

This allows for non-blocking execution and better utilization of system resources.

Avoid Async Void

Avoid using async void methods except for event handlers, as they can lead to unhandled exceptions that are difficult to catch and handle properly.

Instead, prefer using async Task or async Task<T> for methods that can be awaited.

Prefer Task Return Types

Use Task or from a Task”>Task<T> as the return type for async methods whenever possible.

This allows callers to await the method and handle exceptions or perform additional operations asynchronously.

Example :

    [HttpPost]
    public async Task<IActionResult> SendSms1(NotifyRequest request)
    {
        return Ok(await A());
    }
    private async Task<bool> A()
    {
        return await B();
    }

Configure Awaits Correctly

Use ConfigureAwait(false) when awaiting tasks within library code that don’t require synchronization context.

This helps avoid unnecessary overhead by not capturing the current synchronization context.

Example:

Note: ASP.NET Core doesn’t have any SynchronizationContext so it is preferable to use ConfigureAwait(false)

Use Task.WhenAll or Task.WhenAny

When you need to await multiple tasks concurrently, use Task.WhenAll to wait for all tasks to be completed, or Task.WhenAny to wait for the first completed task.

When used method asynchronously awaits multiple asynchronous operations, until all operations are completed.

It’s a very good means of handling a few collections of the Tasks and getting their results together as completion criteria.

Let’s use WhenAll to await the completion of all the running Tasks.

EmployeeDetails[] employeeList = awaitTask.WhenAll(completedTask);

This allows for better parallelism and can improve overall performance.

Handle Exceptions Appropriately

Use try-catch blocks to handle exceptions that may occur within async methods.

Use the await operator inside the try block and handle any exceptions in the catch block.

Properly log and handle exceptions to prevent application crashes and maintain code robustness.

Utilize CancellationToken

Pass a CancellationToken to async methods when possible to support cancellation.

This allows for better responsiveness and the ability to cancel long-running operations when needed.

static async Task<bool> ProcessAsync(HttpClient client, CancellationToken token)
    {
        HttpResponseMessage response = await client.GetAsync(url, token);
        byte[] content = await response.Content.ReadAsByteArrayAsync(token);
       //do something 
        return true;
    }

Do not mix Blocking and Non-Blocking Code

Avoid blocking on asynchronous code by using blocking calls like Task.Wait or Task.Result.

Mixing blocking and non-blocking code can lead to deadlocks and reduce the benefits of asynchronous programming.

Avoid CPU-Bound Operations in Async Methods

Avoid performing CPU-bound operations directly in async methods.

Instead, offload such operations to dedicated worker threads or use parallel processing techniques like Parallel.ForEach to maximize performance.

Example :

private static IList<int> GetAllPrimeNumbers(IList<int> numbers)
        {

            Parallel.ForEach(numbers, number =>
            {
                if (IsPrime(number))
                {
                    primeNumbers.Add(number);
                }
            });

            return primeNumbers.ToList();
        }

Understand Synchronization Context

Be aware of the synchronization context in which your async code is executing. Understand the implications of different contexts, such as UI thread synchronization context in GUI applications.

Example: ASP.NET Core doesn’t need to worry about synchronization as it doesn’t have any SynchronizationContext.

Summary

Today in this article we discussed the best practice of using async and await keywords using which we can develop clean, efficient, and maintainable asynchronous code using async and await in .NET.

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 Async Await in C#.NET – Guidelines and Best Practices first appeared on TheCodeBuzz.

Today in this article, we will cover HTTPS Vs HTTP and their top 10 benefits and differences. Implementing HTTPS (HTTP over SSL/TLS) in your API offers several benefits for security, privacy, and trustworthiness.

Here are some key advantages of using HTTPS over HTTP,

Security

HTTP sends data in plain text, making it vulnerable to eavesdropping, tampering, and data interception.

HTTPS provides data encryption and authentication. It encrypts the data exchanged between the client and the server, ensuring that it remains confidential and cannot be easily intercepted or read by unauthorized parties.

It also uses digital certificates to authenticate the identity of the server, protecting against man-in-the-middle attacks.

Data Encryption between client-server

HTTPS encrypts the data transmitted between the client and the API server.

It ensures that the information exchanged, including sensitive data such as authentication credentials, remains confidential and cannot be easily intercepted or read by unauthorized parties.

Encryption protects against eavesdropping and data tampering.

Secure Authentication

HTTPS enhances the security of authentication processes.

It ensures that login credentials, tokens, or session cookies are transmitted securely, reducing the risk of interception or impersonation.

This is crucial in preventing unauthorized access to APIs and protecting user accounts from being compromised.

Data Integrity – Data in Transit

By combining encryption and integrity checks, HTTPS provides a secure channel for transmitting data over the Internet while ensuring that the data remains unaltered and trustworthy.

HTTPS employs encryption algorithms to secure the data exchanged between the client and the server. This encryption process ensures that the data is protected and remains confidential during transit.

Encryption prevents unauthorized parties from eavesdropping on the communication and accessing the data.

HTTPS performs integrity checks.

After the client sends a request or the server sends a response, the message digest of the transmitted data is recalculated at the receiving end. This recalculation is based on the received data.

The client or server then compares the recalculated message digest with the one sent along with the message.

The cryptographic measures employed by HTTPS protect against unauthorized modifications, tampering, and interception of data during transit, thereby maintaining the integrity of the transmitted information.

In addition to data integrity, HTTPS ensures that the encryption of the data remains intact. The client and server verify the integrity of the encryption by confirming that the encryption keys have not been tampered with or compromised during the SSL/TLS handshake.

Trust and Credibility

Using HTTPS and displaying a valid SSL/TLS certificate demonstrates your commitment to security and builds trust with API consumers.

It assures them that their data is transmitted securely, and their interactions with your API are protected.

HTTPS also helps establish the authenticity of your API server, as the certificate validates its identity.

Protection against MITM (Man-in-the-Middle Attacks)

HTTPS (HTTP over SSL/TLS) helps protect against man-in-the-middle (MITM) attacks, which are a common threat to unsecured connections

HTTPS protects against man-in-the-middle (MITM) attacks where an attacker intercepts and alters the communication between the client and the server.

Employing the below HTTPS ensures the integrity and privacy of the data being transmitted.

• Encryption,
• Certificate validation
• Secure handshake protocols

Compliance with Security Standards

HTTPS has become the industry standard for secure communication on the web.

Using HTTPS in your API aligns with the best practices and expectations of API consumers, establishing your API as a secure and trustworthy service.

Many security standards and regulations, such as PCI DSS (Payment Card Industry Data Security Standard) and GDPR (General Data Protection Regulation), mandate the use of encryption and secure communication protocols like HTTPS when handling sensitive data.

Protection against Information Leakage

HTTPS prevents information leakage and protects against unauthorized access to sensitive data.

It ensures that Application requests and responses are encrypted, reducing the risk of exposure to sensitive information in transit.

Online Visibility and Traffic

SEO Benefit

Many search algorithms used by search engines like Google, and Bing uses HTTPS as a ranking signal.

Using HTTPS in your application can positively impact your search engine rankings, resulting in improved visibility and traffic

Antivirus Flagging

HTTPS-supported applications are recommended by many antivirus software.

Antivirus software generally does not flag HTTPS connections as malicious or suspicious based on the fact that they use HTTPS vs HTTPS.

However flagging also depends on other factors like malware, viruses, or malicious activities, rather than flagging HTTPS connections themselves.

However, any warning signs informing users not to click on such websites result in reduced online visibility and traffic on the website or application.

When to use HTTP Over HTTPS

HTTP (Hypertext Transfer Protocol) is typically used when security and encryption are not a primary concern, and when there is no sensitive information being transmitted.

Here are a few scenarios where using HTTP might be appropriate,

Development and Testing

During the early stages of development or testing, you may use HTTP to simplify the setup and configuration.

It can be easier to debug and monitor HTTP traffic compared to HTTPS, as encryption can add complexity.

Internal Networks

In closed or private internal networks where there is no exposure to the public internet or external threats, using HTTP can be acceptable.

Example: LAN network or communication over private endpoints

This assumes that the network is adequately secured and isolated from unauthorized access.

Non-sensitive Information

If the information being transmitted is not sensitive and does not require confidentiality, integrity, or authentication, such as publicly available data or non-sensitive public APIs, using HTTP may be sufficient.

Performance Optimization

In certain cases, where the overhead of encryption and decryption poses a significant performance impact, and the data being transmitted is not sensitive, HTTP may be preferred over HTTPS to optimize performance.

However, it’s important to note that the use of HTTP should be carefully considered, as it exposes data to interception, tampering, and unauthorized access.

In general, it is recommended to use HTTPS for most scenarios to ensure the confidentiality, integrity, and security of data transmitted over the Internet, especially when dealing with sensitive information or user interactions.

Summary

Overall, implementing HTTPS in your API provides essential security measures to protect data, authenticate users securely, and establish trust with Application consumers. It helps safeguard sensitive information, enhances the integrity of data transmission, and ensures compliance with security standards and regulations.

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.

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 HTTPS Vs HTTP- Top 10 Benefits and Differences first appeared on TheCodeBuzz.

Today in the article we shall learn how to MongoDB Query for field is null or not set i.e doesn’t exist in the database.

We shall verify queries using MongoShell or UI tools like a Compass UI.

Today in this article, we will cover below aspects,

We shall also be running the query using the .NET C# Mongo driver.

If interested to know how to run queries using .NET C# mongo driver please check this article,

Getting started

I have a sample MongoDB document as below in one of the collections. Here we shall be trying to search all the documents where the Author field is NULL or not set in documents.

The field is not set

The below query matches documents that do not contain the Author field.

So far above Mongo documents, we shall get results for only “_id”:”5db5a4476997188b2722c820“

Query Pattern

{  Field Name:  {$exists:false}  }

Example Query

{ Author: {$exists:false} }

Results:

Using Mongo shell

Using Compass UI

Note:

If $exists is false, the query returns only the documents that do not contain the field.

In the above query, we shall get the result as only 1 document.

 $exists when set as true, it matches the documents that contain the field, including documents where the field value is null.

The field is null

The below query matches documents that contain the Author field which is set as null.

Here we are assuming the fields already exist and don’t want to consider the records where records where fields do not exist.

So far above Mongo documents, we shall get results for only id = 5ff50353a29ce9564c2724e2

Query Pattern

{$and:[{Field Name:{$type:'null'}}]}

Example Query

{$and:[{Author:{$type:'null'}}]}

Results:

Using Mongo shell

Using Compass

The field is null or not set

Let’s now see if you have requirements to find the records where Field is not set or does not exist in MongoDB.

Query Pattern

{$and:[{Field Name:null }]}

Query Example

{$and:[{Author:null }]}

The above query does work for the below 2 conditions,

• matches “Author” value is NULL
• and matches “Author” fields don’t exist

Results:

Mongo Shell

Compass UI

That’s all, So today we learned the simple Mongo query for identifying the records where the field is null or not set. It’s pretty easy to prepare the query for such needs.

References:

• MongoDB Naming Conventions and Standards

• MongoDB Query – Fields not set or Field is null

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 MongoDB Query for field is null or not set first appeared on TheCodeBuzz.

Today in this article, we will learn How to use Files- Coding Best practices to be followed.

Handling files properly (being an unmanaged resource) is important and since all file operation uses OS-level operation behind the picture, it’s important to take care of the file handles including read operation or file create or delete operation.

Today in this article, we will cover below aspects,

We will use generic guidelines and will see a few examples using C# code. However, you can use the discussed approaches for any coding language.

Understand File Enumeration – File Best practices

While using FileStream class, you get the ability to specify the FileShare access type another process that can have while dealing with File Processing.

Example of FileShare Enumeration,

Example

     using (FileStream stream = File.Open(filePath,FileMode.OpenOrCreate,               FileAccess.ReadWrite, FileShare.ReadWrite))
            {


                /// You logic here////
            }

There are 5 enumerations that can be used which define the file access level.

FileShare.None

• Allows subsequent opening of the file for reading. If this flag is not specified,
• Any request to open the file for reading (by this process or another process) will fail until the file is closed. However, even if this flag is specified,
• Additional permissions might still be needed to access the file.

FileShare.Read

• Allows subsequent opening of the file for Reading. If this flag is not specified.

• Any request to open the file for writing (by this process or another process will fail until the file is closed. However, even if this flag is specified

• Additional permissions might still be needed to access the file.

FileShare .Write

• Allows subsequent opening of the file for reading or writing.

• If this flag is not specified, any request to open the file for reading or writing (by this processor or another process) will fail until the file is closed.

• However, even if this flag is specified, additional permissions might still be needed to access the file

FileShare .Delete

Allows subsequent deleting of a file.

Proper use of FileShare enumeration will help you resolve the most common issues while dealing with files.

Implements IDisposable for Files

Dealing with File instances or handle is important.

Most file methods are actually core OS-level methods and their associated behavior is determined in the run time.

These file-level classes come under unmanaged resources and hence implement an IDisposable interface in C# language.

Other languages will also have their own way of managing file objects

It’s always safe to use the “using” statement while dealing with files instead of creating and managing the instance ourselves.

Wrap all your code inside “using” statements. it opens the file for reading and writes and closes the file handle once the code scope goes out of using statement.

Implement a Retry pattern for File processing

This is not mandatory but always come in handy while dealing with file exceptions or temporary glitch accessing the file.

The retry mechanism is a very basic and common pattern for I/O operations.

Example :

Retry(() =>PerformFileProcessing(filePath), 3);

Here method PerformFileProcessing performs all file read or write operations.

Example – Simple retry pattern

Implement Thread Synchronization for File -Lock and Unlock

The file can be accessed by multiple threads within the application or by external process threads.

If you have multiple threads attempting to access the same file, consider using a Synchronization mechanism using Lock or another threading synchronization mechanism.

Example

 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());
                }
            }

        }
    }

Watch if the File is in use by another process

Please make sure to verify the file is not opened by another process. If Yes make sure to handle the scenario gracefully. You could retry or exit the operation based on the need.

This could be any specific process on the system or program opening the file at the time when your program or application is already using it. Closing or stopping the other process may resolve the access issue.

There are multiple ways to deal with File Open, Creating, Reading, or writing operations using C# code. Its important to how different methods are being used in the code.

A few examples of File related methods but not limited are as below,

File.Create

File.Open

File.ReadAllText()

File.WriteAllText()

File.ReadAllLines()

File.WriteAllLines()

The above method allows performing Read or writing conveniently.

Example

          
            // Create the file, or overwrite if the file exists.

            using (FileStream fs = File.Create(path))
            {
                byte[] info = new UTF8Encoding(true).GetBytes("This is test file.");

                // Add details to the file.
                fs.Write(info, 0, info.Length);
            }

          

Note: When using File.Create, please note FileShare value of None is used as default behavior i.e no other process or code can access the file until the original file handle is closed.

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 How to use Files- Coding Best practices first appeared on TheCodeBuzz.