Source Code

You can also see the codes in this repository.

Enablling .NET8 for Your Application

As you might have already guessed, the first step is to download the .NET8 from here. Let’s now change the TargetFramework in our both DotNetIpFilter.csproj and DotNetIpFilter.Test.csproj files. You can get the application code from the repositroy mentioned above.

<TargetFramework>net8.0</TargetFramework>

You will also need to update your Microsoft.AspNetCore.OpenApi package to .NET8.

Enable Preview .NET 8 in Visual Studio 2022

If you are trying to create a new application using Visual Studio 200, you may be missing an option to chose the .NET8 framework, to mak sure to get this option, do the following.

1. Update your Visual Studio 2022

2. Go to Tools -> Manage Preview Features

3. Select checkbox Use preview of the .NET SDK (requires restart)

4. Make sure to restart after enabling this

Use .NET8 Contains Method from IPNetwork

Let’s change our IpActionFilter.cs file code as below, to use the Contains method from .NET8 IPNetwork class.

In the code above the variable addressRange is a string that represents IP Address Range and ipAddressToCheck is the IP Address to check. The code for the IPNetwork is here. You can learn more about this IPNetwork.Contains(IPAddress) method here. Make sure to select the version .NET 8 for the doc. If you can’t use .Net 8, you can implement your own class by taking the code from here.

I also have a detailed StackOverflow answer here on this topic.

StackOverflow answer

Test IP Filtering with Ranges

Now, it is time to test our new implementation. Go to the IpFilterService.cs file and then edit the GetAdminSafeIpList method. Assign a few IP address ranges to the variable ipListArray, remember this is where you get a list of IP addresses and ranges from any of your middleware service using an async function. To make it simpler, I am assigning some of the IP addresses and ranges to that variable manually.

When you run the application you can see that the addresses and the ranges we set is getting validated in our OnActionExecuting method in IpActionFilter.cs.

The Contains method retruns true if the given IPAddress is part of the IP network. Otherwise, returns false.

If you inspect the Contains method, you can see the code as below. This works with both IPV4 and IPV6.

Conclusion

In this post we have seen how easily we can check an IP address is in a given IP address ranges or not. Before this .Net8 release, we had to have our own implementaion, but now it is so easy and less codes. Less code is less maintenance, right. The .NET8 has many features just like this, checkout here.

About the Author

I am yet another developer who is passionate about writing and sharing knowledge. I have written more than 500 blogs on my blog. If you like this content, consider following me here,

• GitHub
• medium
• Twitter

Your turn. What do you think?

Thanks a lot for reading. Did I miss anything that you may think is needed in this article? Could you find this post useful? Kindly do not forget to share your feedback.

Create an IP Action Filter

Before you do this, I assume that you already have the .Net Web API. For this post I am using .Net 7. Create a Services folder and then create a class IpActionFilter that is inherited from ActionFilterAttribute.

The implementation is a clone of this doc. As you can see from that doc, there it the safe IP addresses list are static and is added to the App Settings manually. However in my scenario, I had to get this from an Async service call.

Get the IP addresses from an Asyn service call

We will create a new Service IpFilterService that implements IIpFilterService. Here we will mimic the async call to make this post more concrete.

Async call to set the configuration

If you just have a few IP addresses that can easily set in the App Settings. You can just add them manually as in this post. As I wanted to update this list via an async service call, there are a few additional changes we must do. One of them is creating a Hosted Service that implements IHostedService and add that to the builder using builder.Services.AddHostedService. Let’s create IpHostedService.

As you can see from the code above, we are setting the AdminSafeIpList configuration to our App Settings via the code. Now all we need to add is to add this to the builder.

Configure the builder

To make sure that the AdminSafeIpList is updated to the App Settings, we will need to add our IpHostedService as a HostedService. You can learn more about this service here. The code for Program.cs after this changes is below.

So we are passing the AdminSafeIpList to the IpActionFilter.

Enable IpActionFilter as a ServiceFilter

As we have implemented the action filter and other required services, we now can add the IpActionFilter as a ServiceFilter in the controller or the actions. Add the code [ServiceFilter(typeof(IpActionFilter))] to top of controller or actions.

Finally, Add some unit tests

Let’s try to add some unit tests for our IpActionFilter.

Output

Let’s build and run our API. You should see the preceeding response.

With External IPs:

With Internal IPs:

Source Code

You can also see the codes in this repository.

Conclusion

Here in this post we have seen,

1. How we can restrict the accesse to our Web APIs by providing the Safe IP addresses list

2. How to create a new Action Filter and use that for Controllers

3. One of the challenge was to get the IP Address safe list from an Async service call and update the App Settings.

About the Author

I am yet another developer who is passionate about writing and video creation. I have written more than 500 blogs on my blog. If you like this content, consider following me here,

• GitHub
• medium
• Twitter

Your turn. What do you think?

Thanks a lot for reading. Did I miss anything that you may think is needed in this article? Could you find this post useful? Kindly do not forget to share your feedback.

Prerequisites

Download the Targeting framework, and install it. In my case, NET5. You can download them from here.

Upgrade Assistant tool by Microsoft

If you choose to use the Upgrade Assistant tool by Microsoft, all you have to do is to install visual studio, install the try-convert tool by running the preceding command.

Install try-convert: dotnet tool install -g try-convert
Update try-convert: dotnet tool update -g try-convert

Now install the upgrade assistant by executing the below command.

dotnet tool install -g upgrade-assistant

Just like any other tools, to update the tool, just run the below command.

dotnet tool update -g upgrade-assistant

To get more info about the installation, you can visit this document.

Porting Assistant tool by Amazon

If choose to use this tool, please make sure that you have done the preceding things.

• Signup an account with AWS
• Log in to the AWS account and collect the security credentials. We will be using this info in our migration. Visit this site, click on the Access Keys section, and then click on the Create New Access Key button. This will generate a new key, download the same and keep it in a safe location.

• Go to this link, click on the Download Porting Assistant for the .NET button to download and install. You can also use the Visual Studio extension from here.

Port the Application

In this section, let’s see how we can use both tools.

Using Upgrade Assistant tool

Using the upgrade assistant tool is as easy as you type some writing some basic commands in CLI. If you have worked with any CLI tools before, this would be very easy.

Once you have installed the tool, you can run the preceding command to start the process.

upgrade-assistant upgrade <Path to csproj or sln to upgrade>

This will analyse your solution or the project and give you the commands to perform as in the preceding image. The first step is to select the entry point from your solution, if you are trying to port the entire solution.

The next step is to select the project and select the commands to perform each task. Please remember that you will have to do this for each project. In my case, I was having 43 projects, if you have more projects it can be a pain. Your screen should look like the preceding image.

Please keep in mind that I am upgrading my MVC application, and the commands will be slightly different for other .NET framework app types. See more here. Once the tool has gone through all the projects, the last step is to finalize the upgrade. As always, all you have to do is selecting the command.

You should get a message as preceding once the upgrade has been completed.

[22:43:27 INF] Upgrade has completed. Please review any changes.
[22:43:27 INF] Deleting upgrade progress file at C:\sourcecode\solution-name.upgrade-assistant
PS C:\sourcecode\solution-name>

Upgrade output

It is worth noting that you will have to manually do a lot of changes in your solution according to how complex your solution is. Some of the warnings/errors that this tool gives are given below.

• No version of System.Configuration.ConfigurationManager found that supports [“net46”]; leaving unchanged
• No version of System.ServiceModel.Federation found that supports [“net46”]; leaving unchanged
• .NET Upgrade Assistant analyzer NuGet package reference cannot be added because the package cannot be found
• Package AutoMapper has been upgraded across major versions (4.2.0 -> 5.2.0) which may introduce breaking changes
• No version of EnterpriseLibrary.TransientFaultHandling found that supports [“net5.0-windows”]; leaving unchanged
• No version of EnterpriseLibrary.TransientFaultHandling.Data found that supports [“net5.0-windows”]; leaving unchanged
• No version of Microsoft.AspNet.WebApi.OData found that supports [“net5.0-windows”]; leaving unchanged
• No version of Microsoft.Azure.CosmosDB.Table found that supports [“net5.0-windows”]; leaving unchanged
• No version of Microsoft.Azure.DocumentDB found that supports [“net5.0-windows”]; leaving unchanged
• No version of Microsoft.Bcl.Async found that supports [“net5.0-windows”]; leaving unchanged
• Package Microsoft.Web.Xdt has been upgraded across major versions (2.1.1 -> 3.1.0) which may introduce breaking changes
• Package Microsoft.Azure.NotificationHubs has been upgraded across major versions (1.0.9 -> 2.0.2) which may introduce breaking changes
• No version of SharePointPnPCoreOnline found that supports [“net5.0-windows”]; leaving unchanged
• Package Microsoft.Azure.NotificationHubs has been upgraded across major versions (1.0.9 -> 2.0.2) which may introduce breaking changes
• No version of System.ServiceModel.Federation found that supports [“net46”]; leaving unchanged
• No version of Microsoft.Azure.ActiveDirectory.GraphClient found that supports [“net5.0-windows”]; leaving unchanged
• Package Microsoft.Azure.WebJobs has been upgraded across major versions (1.1.2 -> 2.3.0) which may introduce breaking changes
• No version of Microsoft.ApplicationInsights.Web found that supports [“net5.0-windows”]; leaving unchanged
• No version of Microsoft.AspNet.WebApi.Owin found that supports [“net5.0-windows”]; leaving unchanged
• No version of StackifyHttpModule found that supports [“net5.0-windows”]; leaving unchanged
• No version of System.IdentityModel.Tokens.ValidatingIssuerNameRegistry found that supports [“net5.0-windows”]; leaving unchanged
• No version of WebApiContrib.Formatting.Jsonp found that supports [“net5.0-windows”]; leaving unchanged
• No version of Microsoft.AspNet.WebApi.Cors found that supports [“net5.0-windows”]; leaving unchanged
• No version of Microsoft.AspNet.WebApi.Tracing found that supports [“net5.0-windows”]; leaving unchanged
• Package NJsonSchema.CodeGeneration has been upgraded across major versions (1.39.5923.31344 -> 2.65.6055.39156) which may introduce breaking changes

Using Posting Assistant tool

This is how you can use the Porting Assistant tool.

Configure the Porting Assistant tool

Once the tool is installed, open the same and click on the Get started button.

In the new screen, select the target framework and then click on the Add named profile link and provide the Access key information we get from the AWS console.

Click on the Add button, if you want to know more about the named profile, this has everything documented. This is how your screen should look like now.

Using the porting assistant tool

From the above screen, click on the button Next. From here you can select your solution file that holds all of your projects. The tool will start analysing your solution bytes by bytes, depending on the complexity of your solution, this can take a while.

The system will give a message as in the preceding image once the analysing is finished. The screen will also contain information about your Incompatible packages, Incompatible APIs, Build Errors, Porting actions, etc.

Click on the solution name, in the screen you will be able to either select all the projects or one by one at a time and start the porting process.

Clicking on the button Port solution redirect you to another screen, that is where you can change the versions of your packages. And once you finalized that, click on the port button. You should now see a notification saying that the porting has started.

You will also be getting an option to view the logs at the end.

Things to keep in mind

• These tools are just a starting point, and according to the complexity of your application, and the number of APIs or packages incompatible, you may have to manually edit the code and change the package references.
• It will be helpful if you choose to save the accessed solution in the same place if you use any Git branch so that you can see the changes and act accordingly.
• If you use Microsoft Upgrade Assistant, you can choose the given order to perform the port or if you use Amazon Porting Assistant, you can select which project you should be migrated first according to the graph in the Project references tab.

More information about the tools

The .NET Upgrade Assistant is a CLI tool introduced by Microsoft, and with this tool, you can easily migrate any old application to new versions. You can read more about this tool here.

The tool “Porting Assistant for .NET” is developed by Amazon. You can read more about this tool here.

To get more understanding about this “Porting Assistant for .NET” tool, I recommend you to watch the preceding video.

Conclusion

In this post, we learned the preceding things.

• What is Upgrade Assistant tool from Microsoft
• How to configure and use Upgrade Assistant tool from Microsoft
• How to migrate from old .NET framework project to new .NET 5 version
• What is the Porting Assistant for the .NET tool
• How to configure the Porting Assistant for the .NET tool

I will be updating this post if I find any information needs to be added in the future.

About the Author

I am yet another developer who is passionate about writing and video creation. I have written close to 500 blogs on my blog. And I upload videos on my YouTube channels Njan Oru Malayali and Sibeesh Passion. Please feel free to follow me.

• GitHub
• medium
• Twitter

Your turn. What do you think?

Thanks a lot for reading. Did I miss anything that you may think is needed in this article? Could you find this post useful? Kindly do not forget to share your feedback.

Kindest Regards

Sibeesh Venu

Introduction

Building a UWP application is fun but releasing them not. At least that is the experience I had, I was facing a bunch of issues when I try to configure the pipeline to build and release to the app center. Yes, it includes the creation of a certificate too, and here we will see the best practice to handle your certificate. And we will also use the option Variables in the Azure DevOps.

Here in this article,

• we will create the pipelines from the scratch
• we will create a certificate and save it under the secured files
• we will use the certificate to signin the build in the pipeline
• we will create variables for our pipeline
• we will also use some of the existing tasks like, copy, archive etc
• and at the end, we will distribute our artifact to the app center

If any of the above points mentioned felt interesting, then you are in the right place. Let’s read further.

Welcome to the Pipeline World

Azure DevOps pipeline has a lot to offer, and I am yet to experience all the features it provides. Here I am assuming that you already have a UWP application, and if you have not you can get some sample UWP applications from the official GitHub repositories, I will leave this task to you.

Creating a certificate

The first thing that we need to do is to create our certificate file (PFX). To do that, we already have a nice tutorial on the Docs. If you have followed the tutorial, at the end you should be having a PFX file saved in some folder as per your preference.

Please make a note of the location you had saved your PFX file and the Thumbprint.

What is the difference between a PFX file and Cert file?

A PFX will have both private and public key in it, and cert file will have only public key in it. Thus sharing a PFX file outside your organization is not a good idea.

PFX VS Cert

What is a Thumbprint?

A Thumbprint is a hexadecimal string that can be used to identify the certificate

Thumbprint

Now somehow you forgot your Thumbprint, the same can be easily found in this location in Windows.

C:\Users\sibee\AppData\Roaming\Microsoft\SystemCertificates\My\Certificates

Setting up the variables

As we now have our certificate and the details ready, let us set up our variables in the Azure DevOps pipeline. To do that, go to the library section of the pipeline and click on the +Variable group.

Below is the Variable Group I had created with all the details.

Please do not forget to enable the “Allow access to all pipeline” or else you will always get an error in your pipeline. Here the signingCert.secureFilePath is the file path of our PFX file, which we will upload to our secure file section of the pipeline. We will talk about the appSlug and distributionGroupId when we create the distribute to app center task in our pipeline.

Upload the certificate to the Secure Files

To upload our PFX file generated, click on the Library and then Secure files, and upload the file by clicking on the +Secure file.

Generate build number automatically (Optional)

This step is optional. Unfortunately by default the Azure DevOps release to app center task will not increase the build number, thus you will always see the same version number as 1.0.0 in the app center.

And if you want to change it to something like the preceding image, then you can consider reading this step.

The first thing that you need to do is to install this package to your organization. Once you have done that, you should be able to see related tasks when you search for the term “Version” in the pipeline.

Create the Pipeline

Below is my fully functioned YAML file, I will be explaining all the tasks here.

To start with I wanted to make sure that my build is manual, so I started editing my YAML file as follows.

As I was mentioning before, we wanted to make sure that the version number of our app releases are different, thus I assigned the name property as below.

name: $(MajorVersion).$(MinorVersion).$(date:yy)$(DayOfYear)$(rev:.r)

Do you remember that we created a Variable Group and now it is the time use it.

Please be noted that you must use the format -name: “” value: “”

Tip for Pipeline Variable Configuration

Once this is done we install all of our Nuget Packages. This is something that we do for all our pipeline thus I am not going to explain this task.

Now it is time to download our certificate from the secured files. To do that we need to add the task below.

As you can see that we use the variable signingCert.secureFilePath to locate the secure file. Please also be noted that the name property, we will be using this in upcoming tasks.

As we downloaded the certificate already, now it is time to install our certificate in our agent so that we can do the package siginin.

Did you notice that we used mySecureFile.secureFilePath to get our certificate and the password from the variable?

Once this is done, we can add a task to automatically increase the build number of our artifacts. Remember that we installed a package to do so? If not, please consider read this article from the start again, just kidding!.

As we have a UWP application, we should use the task Version APPX manifest, please remember that the task names are different for the other types of applications. This task will update the related environment variables.

Now let us add a task to build our application.

Please be noted that these build arguments.

• p:AppxPackageSigningEnabled=true
• p:PackageCertificateThumbprint=”$(signingCert.thumbprint)”
• p:PackageCertificateKeyFile=”$(mySecureFile.secureFilePath)”
• p:PackageCertificatePassword=”$(signingCert.password)”

These are the settings that you need to enable to do the build signin.

So far so good, as per the weight of your application, the build task can take longer than expected. Please keep in mind that the default timeout value of the Azure DevOps pipeline is 60 minutes, so if your build is taking more than an hour, then your build will be failing.

Once the build is successful, we can copy and publish our artifacts. Are you ready?

Yay!. We are almost done. I was facing an issue as “Ask the app developer for a new app package. This one isn’t signed with a trusted certificate (0x800B0100) ” when I try to install the application after downloading the application from the app center. And this GitHub post helped me to fix the same.

So as a fix, I had to upload the entire artifacts to the app center instead of the APPX file alone, to do so, we have to create an Archive task as follows.

So now we have our complete artifacts ready to upload to the app center. Let’s create the task for that. Below is my task, I will explain the inputs needed for this task.

Before you add that task, make sure that you get the values for the below inputs.

• Server End Point
• App Slug
• Distribution Group Id

Now let’s get these values. The server end point is the name of the connection that you should create. You will be asked to do this while you add the App Distribute Task to the YAML file. Please make sure that you have enough permission to do so.

You should also need to create an API token in your App Center to create this connection, you need to go to https://appcenter.ms/settings/apitokens and then click on the New API Token button.

Please make sure that you give Full Access when you create the API Token.

The app slug is in the format of {username}/{app_identifier}. To locate {username} and {app_identifier} for an app, click on its name from https://appcenter.ms/apps, and the resulting URL is in the format of https://appcenter.ms/users/{username}/apps/{app_identifier}. If you are using orgs, the app slug is of the format {orgname}/{app_identifier}.

When you are uploading the artifacts in the zip file format, it is mandatory that you should provide the build number in the task, otherwise you will get an error as “Job: “”{\”status\”:\”error\”,\”message\”:\”Version could not be created from build.\”}” http response code: 422″” in the pipeline. So to fix this we can add the input buildVersion: ‘$(Build.BuildNumber)’

And then I set the appFile as the archive file task output.

We usually have many people in out projects, and if the project is a critical ones, the number of people is more. But most of the cases, all of them will not be developers, some might be testers and some may be business people. So isn’t it a good idea to have a group of people to whom we can send notifications to, whenever we have any new releases, these can be Testers, Developers, Business etc. Luckily App Center has this feature of Groups. I created a Group called Testers and then I used this Group in my pipeline, to make sure that the notifications are sent only to these members.

To create a group, Click on the Groups in the App center and then create one, once it is created assign the members. Now you can click on the settings button of the group and get the Group Distribution Id, which we will use in the pipeline.

Please do not forget to update the values of appSlug and distributionGroupId in the Pipeline Variables.

With this we are done with our configuration.

Run the Pipeline

As we have successfully configured our pipeline, now is the time to run the same. If everything goes well, you should be getting an output as below.

Now let us go to our app center and see the new release.

Now you can download the file and install your application. If you extract the files, you should be able to see all the related files inside including the certificate.

Now all you have to do is, to double click on the APPXBUNDLE file to install the application.

References

• How to build, sign and deploy your UWP application using Azure DevOps and App Center
• Create Certificate

Conclusion

Thanks a lot for staying with me for a long time and reading this article. I hope now you have learned

• about creating a certificate for your UWP application
• about Azure DevOps Variables
• about Azure DevOps secured files
• about siginin the UWP package in the Azure DevOps pipeline
• about building the UWP application
• about archiving the build artifacts before uploading to the app center
• about configuring the distribute app center task in the Azure DevOps
• about automatically updating the version number of your UWP application release

If you have learned anything else from this article, please let me know in the comment section.

Follow me

If you like this article, consider following me, ha ha!.

• GitHub
• medium
• Twitter

Your turn. What do you think?

Thanks a lot for reading. Did I miss anything that you may think which is needed in this article? Could you find this post as useful? Kindly do not forget to share me your feedback.

Kindest Regards
Sibeesh Venu

Introduction

In our previous article we have already seen that how we can use Quartz.Net scheduler in our Asp.Net core console application and then run it as a windows service. The problem with that approach is that, the scheduler information will be lost once the system restarts or something bad happens. To rectify that problem we can actually save all the scheduler information in a database, luckily the Quartz.Net scheduler supports this and we can easily implement it. I hope the introduction is clear and let’s jump on to the implementation.

Source Code

The source code can be found in this GitHub repository. Please feel free to star, fork or do whatever you wish. You can also consider follow me on GitHub. LOL.

Setting Up Database

Before we start the coding, let us set up our database. You can choose any database as you wish. I am choosing SQL Server Express.

Install SQL Server Express

Enable sa Login

We should enable the sa login which we will use in our Quartz configuration. If you try to configure the Quartz with windows authentication, you will get an error as below.

2019-08-29 11:34:02.3570|INFO|Quartz.Core.QuartzScheduler|JobFactory set to: Backup.Service.Helpers.CustomJobFactory
2019-08-29 11:34:12.6801|INFO|Quartz.Impl.AdoJobStore.JobStoreTX|ConnectionAndTransactionHolder passed to RollbackConnection was null, ignoring
2019-08-29 11:34:12.6892|ERROR|Quartz.Impl.AdoJobStore.JobStoreTX|Failure occurred during job recovery: Failed to obtain DB connection from data source ‘default’: System.Data.SqlClient.SqlException (0x80131904): Cannot open database “BackupClientSchedules” requested by the login. The login failed.
Login failed for user ‘WORKGROUP\DESKTOP-3EF5B65$’.
at System.Data.SqlClient.SqlInternalConnectionTds..ctor(DbConnectionPoolIdentity identity, SqlConnectionString connectionOptions, SqlCredential credential, Object providerInfo, String newPassword, SecureString newSecurePassword, Boolean redirectedUserInstance, SqlConnectionString userConnectionOptions, SessionData reconnectSessionData, Boolean applyTransientFaultHandling)
at System.Data.SqlClient.SqlConnectionFactory.CreateConnection(DbConnectionOptions options, DbConnectionPoolKey poolKey, Object poolGroupProviderInfo, DbConnectionPool pool, DbConnection owningConnection, DbConnectionOptions userOptions)
at System.Data.ProviderBase.DbConnectionFactory.CreatePooledConnection(DbConnectionPool pool, DbConnection owningObject, DbConnectionOptions options, DbConnectionPoolKey poolKey, DbConnectionOptions userOptions)
at System.Data.ProviderBase.DbConnectionPool.CreateObject(DbConnection owningObject, DbConnectionOptions userOptions, DbConnectionInternal oldConnection)
at System.Data.ProviderBase.DbConnectionPool.UserCreateRequest(DbConnection owningObject, DbConnectionOptions userOptions, DbConnectionInternal oldConnection)
at System.Data.ProviderBase.DbConnectionPool.TryGetConnection(DbConnection owningObject, UInt32 waitForMultipleObjectsTimeout, Boolean allowCreate, Boolean onlyOneCheckConnection, DbConnectionOptions userOptions, DbConnectionInternal& connection)
at System.Data.ProviderBase.DbConnectionPool.TryGetConnection(DbConnection owningObject, TaskCompletionSource1 retry, DbConnectionOptions userOptions, DbConnectionInternal& connection) at System.Data.ProviderBase.DbConnectionFactory.TryGetConnection(DbConnection owningConnection, TaskCompletionSource1 retry, DbConnectionOptions userOptions, DbConnectionInternal oldConnection, DbConnectionInternal& connection)
at System.Data.ProviderBase.DbConnectionInternal.TryOpenConnectionInternal(DbConnection outerConnection, DbConnectionFactory connectionFactory, TaskCompletionSource1 retry, DbConnectionOptions userOptions) at System.Data.SqlClient.SqlConnection.TryOpen(TaskCompletionSource1 retry)
at System.Data.SqlClient.SqlConnection.Open()
at Quartz.Impl.AdoJobStore.JobStoreSupport.GetConnection() in C:\projects\quartznet\src\Quartz\Impl\AdoJobStore\JobStoreSupport.cs:line 323
ClientConnectionId:2efd5ab8-71aa-4598-b5ca-63c5aaa6afbe
Error Number:4060,State:1,Class:11

Yes, that is such a log error, and we don’t want any errors right. So let us configure sa login first. I have already explained how you can do that , in one of my StackOverflow answer, you can see that here.

Create Database and Tables Needed

Now we need to create a database and some tables where we can save the scheduler and trigger information. You can always see the table schema here in this official Quartz GitHub repository. You can also find the same file in our source code.

Before you run that query in your SQL Server Management Studio, make sure to create a database first and the use the same.

CREATE database BackupClientSchedules
USE BackupClientSchedules

Now id you see inside the database BackupClientSchedules, you should see some tables with no data inside.

Configure Quartz.Net to Use Database Instead of RAM

As we have already set up our database, now we can start configuring the service. If you are new Quartz.Net scheduler, I strongly recommend you to read my previous article.

Edit App.config

Let’s change the App.config file as preceding.

Note that we have set quartz.dataSource.default.provider as Sqlserver and also given the quartz.dataSource.default.connectionString. You should change these values with your provider and connection string.

Install the Nuget Package

We should install the Nuget package Quartz.Serialization.Json in our application.

Setup the Scheduler

In our previous article, we have see how we can setup the scheduler and we were using a function called GetScheduler for the same. Now we can edit the code of that function as preceding.

Please note the comments in the above code block.

Install the Service

Once we finished the above steps, we can run dotnet publish command with release configuration and install the service as preceding.

Again, read my previous article, if you need a detailed explanations about this step.

Output

Once the service started successfully, you should be able to see two log files backupclientlogfile_backupservice.txt and backupclientlogfile_helperservice.txt in our win7-x64 folder. You can see all the logs in this files.

You should also be able to see some scheduling information in our tables in our database. Some of the table’s screenshots are given below.

Conclusion

Wow!. Now we have learned,

• about Windows Service and Asp.Net Console Application
• about How to create a Windows Service using Asp.Net Core
• about How to use Quartz scheduler with database

Your turn. What do you think?

Thanks a lot for reading. Did I miss anything that you may think which is needed in this article? Could you find this post as useful? Kindly do not forget to share me your feedback.

Kindest Regards
Sibeesh Venu

Introduction

Windows services are a good way for reducing some manual jobs that we have to do in our system. In this article, we are going to write a windows service using Asp.Net core, the jobs of this windows service is given below.

1. Zip the folder and save the file to a particular directory
2. Upload the zipped folder to the Azure blob storage

The above mentioned tasks will be running daily, weekly, monthly. We are using Quartz scheduler with Dependency Injection to do this amazing tasks. We are using Nlog for logging the details of our tasks. If you think this is something that you are interested at, then you are at the right place, let us develop our PerfectScheduler.

Source Code

The source code of this project is been uploaded to the GitHub, please feel free to fork, star, create pull requests etc. The repository can be found here.

Creating Perfect Scheduler

As I mentioned earlier, we are creating a windows service with Asp.Net core, technically there is no straight way to do this, as the Windows Service with Asp.Net core template is not available in Visual Studio.

so we will be creating an Asp.Net console application and then install executable file generated as a windows service.

Creating an Asp.Net Console Application

Open Visual Studio and search for the project template Console App(.Net Core) and name the solution as per your convenience, I am naming this project as Perfect Scheduler, as I am thinking that we, the community people can make this windows service perfect by creating many pull requests.

Once you had created the application, let us install all of our dependencies at once, so that we don’t need to worry about them later.

Write the Service

As we have installed all of our dependencies, let us create our service now. Add a new class with the name BackupService and inherit the same from IHostedService, which is part of Microsoft.Extensions.Hosting namespace.

The IHostedService has two methods in it as follows, so we should implement them in our service class.

StartAsync

The StartAsync method can be implemented as preceding.

As you can see that in the first line of the above code, we are getting the scheduler of Quartz. Let us create a method and return a scheduler then.

The next step is to build a service provider so that we can inject our dependencies using Constructor Dependency Injection. By default the Quartz is not doing this, so we have to build the configuration our own.

As you can see that we have configured the services for DailyJob, WeeklyJob, MonthlyJob and HelperService. No worries, we will be creating these Classes and Interfaces very soon.

Once we get the Service Provider, we can pass this to our Custom Job Factory, which we will be implementing soon. Now, we can start the scheduler and schedule our jobs, please make sure that you are using different Identity names for both Triggers and Jobs. The samples are given below.

StopAsync

The StopAsync method can be implemented as follows

Creating the JobBuilders and TriggerBuilders

Now we can create the Interfaces and Classes for our Jobs, which are Daily, Weekly, Monthly. To do so, let us create a new folder called Helpers and then create a folder called Interfaces inside. Below are the Interfaces you need to create then.

IDailyJob

IWeeklyJob

IMonthlyJob

Let us also create an Interface for our HelperService.

IHelperService

The parameter schedule is for determining which job it is, the value of this parameter can be daily, weekly, monthly.

Create a Custom Job Factory

To implement the Dependency Injection, we need to create our own custom job factory. Create a class inside the Helper folder as preceding.

Implement the Job Builder Interfaces

Now it is time to implement our Daily, Weekly, Monthly job builders.

DailyJob

WeeklyJob

MonthlyJob

As you can see that we have configured separate classes for our each jobs with the dependency IHelperService injected via constructor. In the future we should be able to write custom logic for each jobs here as it is in separate classes.

Implement HelperService

Before we start implementing this service let us configure the NLog now as we will be writing logs from this class.

Configure NLog

To configure, NLog, create a new configuration file NLog.config and edit the content as preceding.

Now, create a method SetUpNLog() and add the codes as below.

Please make sure that you have already added a property ILogger _logger.

We can implement the HelperService as preceding with all the necessary private and public methods.

The method PerformService(string schedule) will be called for every schedule and it will make sure that the below tasks are performed.

1. Zip the folder and save the file to a particular directory
2. Upload the zipped file to the Azure blob storage

Here, the values of the the variable and the blob storage container names are same, that is, daily, weekly, monthly. If you are not sure how you can upload a blob to Azure storage account, I strongly recommend you to read my article here.

Remember to set the values for the FolderToZipLocation(To which location the file should be saved), FolderFromZipLocation (From where the files should be taken), StorageConnectionString in the App.config file.

Setting Up The Program

As you all know that Program class it the start of our console application, not it is time to call our BackupService from the Program class. Let us edit the code of the Program class as below.

If we are running the application locally/debug, we are calling the extension method RunConsoleAsync() or else we call our own custom extension method RunTheServiceAsync(). The line services.AddHostedService() is very important as this is where we register our IHostedService, which is BackupService. Below is the code for our extension method.

The ServiceLifetime class is where we override the methods from ServiceBase class. You can find the implementation as follows.

Creating the Windows Service

As we have already created the Asp.Net Core console application, now it is time to create a windows service from it. Make sure that you had set the RuntimeIdentifier to win7-x64 and SelfContained to true in the properties of your project, this will make sure that all of your dependencies are being added to your executable file, so that you don’t need to worry about handling your dependencies manually. You can read more about it here. To do so, right click on the project and click on Edit Project File. At the end, your csproj file should be similar as preceding.

Create the Release Configuration

You should also run the dotnet publish command with the release configuration before you try to install the service, because you need this executable file to install the service.

Open the command prompt with administrator privilege and go to the project root folder using the cd command. Run the command “dotnet publish –configuration=release” .

This will generate everything you wanted. If you run the command correctly, you should see an output as preceding.

Now go to the bin folder and then release folder, you should see a folder with the name netcoreapp2.1, inside this folder, there will be a folder win7-x64, this is the folder where your exe file, log file and other items are residing.

Install the Service

To install our Asp.Net console application as a windows service, you can use the sc command. Open the command prompt with administrator privilege and run the preceding command.

And then you can start the service by running the command as “sc start BackupService”. This should start your service.

Giving Permission to the Folders

Sometimes you may get some permission issue in your service as it doesn’t have enough permission to read the files form the C drive. To overcome this, you should give enough permission to the user. You can do this by editing the security properties of those folders.

Do the same for the BackupZip folder as well.

Output

If you have run the service correctly, you should see a log file with the name backupclientlogfile.txt inside your win7-x64 folder. Once the service is run, the logs will be written as follows.

You can also check your Azure Storage account to check whether the files have uploaded correctly or not.

Conclusion

Wow!. Now we have learned,

• about Windows Service and Asp.Net Console Application
• about How to create a Windows Service using Asp.Net Core
• about How to use Quartz scheduler
• about How to use NLog in Windows Service
• about How to configure Quartz scheduler to use Dependency Injection
• about How to Zip a folder and save the file
• about How to upload a file to the Azure blob storage

Your turn. What do you think?

Thanks a lot for reading. Did I miss anything that you may think which is needed in this article? Could you find this post as useful? Kindly do not forget to share me your feedback.

Kindest Regards
Sibeesh Venu

Introduction

Many of you might have been developing applications in Net Core 2.0 version, as that was the main release with lots of features. But did you know that the next big release has already happened with some additional features in Net Core journey? Have you already migrated your applications to Dot Net Core 2.1.x version already? If you haven’t, no worries, here in this post, we are going to cover talk about how we can migrate/update our applications to the new version of Dot Net Core. I hope you will like this article.

Background

As I said, this post is only going to cover the steps you may have to take to update your existing Dot Net Core application to 2.1.x. And I will be not be talking about what is Dot net core? And why dot net core is important? etc, if you have those queries in your mind, I strongly recommend you to read the Microsoft document here.

We will be creating a Dot net Core 2.0 application first, and then we will update the same to 2.1.x version. Sounds good?

.Net Core 2.0 to 2.1.x

Let’s create a .net core 2.0 application

As usual open your favorite IDE, Visual Studio 2017, Click on File -> New Project

As you can see, Asp Net Core version is 2.0.

You can even check the version in your application properties.

Now let’s run our application and see the output.

Update Visual Studio 2017 to the latest

As a first step, to work with Dot net core 2.1 you need to update your IDE. There are a couple of ways you can update your IDE, but the easiest way is to go check the Notifications panel. Let’s see how to do that.

Go to the View tab and click on Notifications

Now you can see all the notifications here as shown in the below image. I always update my Visual Studio whenever there is an update, so you won’t be able to see that notification here on my panel. If you haven’t updated, and if you check the Notifications panel, I am sure you will get a link to the update here. You will be able to do further.

Once you have updated, you can verify your version.

Install latest Dot Net Core

Here I am going to download the latest version from here, however, you can select which version you want from here.

As you can see that we have installed Dot Net Core SDK, Dot Net Core Runtime, Asp Net Core Runtime, and now you can see that the new version is available for you in Visual Studio 2017.

Changing the Target frameworks

As the first step, we need to change the Target framework for our application. Here you can select it in the Properties or you can edit the dot(.)csproj file.

Now it is time to change the Microsoft.AspNetCore.All to Microsoft.AspNetCore.App, as with this version Microsoft have reduced the number of dependencies. We always need to install only the needed things right, instead of everything.

You will always need to change all of your references to the new version. Here I just wanted to show how you can do that. So, look into the packages you have in your application and change it accordingly.

What is new in Dot(.) Net Core 2.1.x

The Dot Net Core 2.1.x is a release with some cool new features, I strongly recommend you to read those here.

I may write a new post with this features soon.

Conclusion

Thanks a lot for reading. Did I miss anything that you may think which is needed? Could you find this post as useful? I hope you liked this article. Please share me your valuable suggestions and feedback.

Your turn. What do you think?

A blog isn’t a blog without comments, but do try to stay on topic. If you have a question unrelated to this post, you’re better off posting it on C# Corner, Code Project, Stack Overflow, Asp.Net Forum instead of commenting here. Tweet or email me a link to your question there and I’ll definitely try to help if I can.

Kindest Regards
Sibeesh Venu

Introduction

Here, in this post we are going to a see some LINQ queries, which covers both basics and advanced. LINQ queries are introduced few years back to offer a consistent way for working with data across many datasources and formats. In LINQ queries, you will always work with objects, which makes it simple to write. I hope you would have already written lots of LINQ queries already, if you haven’t, I strongly reccommend you to read this blog where you can find the answer for, why do we need to use LINQ?. Here I am going to create a MVC demo application. I hope you will like this. Now let’s begin.

Download Source Code

Background

Whenever I get a chance to write some server side codes in C#, I always write it using LINQ. And few weeks back, I was assigned to a training programme where my job was to teach LINQ, hence this post covers the the queries I have written for the training programme. Hope you will find it useful.

Using the code

A LINQ query can be written in two ways.

There are so many articles available in the Internet on the topic LINQ, but most of them dont cover the differences of writing the queries in two possible ways, the motive of this article is to write the queries in both ways, so that you can understand the differnces.

As I mentioned, we are going to create an MVC application, we need to create it first and then configure the entity. Let’s go and do that.

Create a database

To get started with we need to configure our database first. To do so, either you can download the Wild World Importers from here or you can run the script file included in the downlaod link above.

Once after you created the database, you can create your MVC application and Entity Data Model in it.

Configuring MVC application with Entity Data Model

By this time, I hope you would have configured your MVC application with Entity Data Model. Now it is time to create a controller and Entity object.

[csharp]
using System;
using System.Collections.Generic;
using System.Data.Entity;
using System.Linq;
using System.Web;
using System.Web.Mvc;
using System.Windows.Forms;
using LINQ_B_to_A.Models;
namespace LINQ_B_to_A.Controllers
{
public class HomeController : Controller
{
// GET: Home

public MyDataModel DtContext { get; set; } = new MyDataModel();
}
}
[/csharp]

Now we can write some LINQ queries as everything is set to get started.

Setting up the Index view with possible actions

This is just to call the actions we are going write. Let’s see the Index page now.

[html]
@{
ViewBag.Title = "Index";
Layout = "~/Views/Shared/_Layout.cshtml";
}

<h2>Index</h2>
<input type="button" class="btn-info" onclick="location.href=’@Url.Action("LoadAll","Home")’" value="Load All – Query Expression"/>
<input type="button" class="btn-info" onclick="location.href=’@Url.Action("JoinWithWhere","Home")’" value="Join With Where" />
<input type="button" class="btn-info" onclick="location.href=’@Url.Action("LeftJoin","Home")’" value="Left Join" />
<input type="button" class="btn-info" onclick="location.href=’@Url.Action("DistinctSample","Home")’" value="Distinct Sample" />
<input type="button" class="btn-info" onclick="location.href=’@Url.Action("EqualsSamples","Home")’" value="Equals Sample" />
<input type="button" class="btn-info" onclick="location.href=’@Url.Action("NotEqualsSamples","Home")’" value="Not Equals" />
<input type="button" class="btn-info" onclick="location.href=’@Url.Action("PagingQueries","Home")’" value="Paging Queries" />
<input type="button" class="btn-info" onclick="location.href=’@Url.Action("MathQueries","Home")’" value="Math Queries" />
<input type="button" class="btn-info" onclick="location.href=’@Url.Action("StringQueries","Home")’" value="String Queries" />
<input type="button" class="btn-info" onclick="location.href=’@Url.Action("SelectMany","Home")’" value="Select Many" />
[/html]

LINQ Basic to Advanced Index View

Normal Select Query With StartWith and Take

Let’s have a look at the preceding query.

[csharp]
/// <summary>
/// Linq query with Select
/// </summary>
/// <returns></returns>
public ActionResult LoadAll()
{
var loadAllData = (from d in DtContext.Cities where d.CityName.StartsWith("C") select d).Take(10);

//Method Chain Format
var loadAllData1 = DtContext.Cities.Where(d => d.CityName.StartsWith("C")).Take(10);

return PartialView(loadAllData);
}
[/csharp]

As you can see, we are just fetching the data from Cities in both ways. And we are using StartWith as a filter, which actually looks for the city names which starts with the letter C, and finally we are taking 10 elements from it. The first query is the “Query syntax” and the second one is “Method chain”. Personally I like the second way. How about you?

[html]
@model IQueryable<LINQ_B_to_A.Models.City>
<style>
dd, dt, pre {
border: 1px solid #ccc;
padding: 5px;
margin: 5px;
width: auto;
width: 20%;
}

dd {
background-color: #a9a9a9
}
pre {
width: auto;
}
</style>
<dd>City Names</dd>
@foreach (var ctyObj in Model)
{
<dt>@ctyObj.CityName</dt>
}
<pre>
public ActionResult LoadAll()
{
var loadAllData = (from d in DtContext.Cities where d.CityName.StartsWith("C") select d).Take(10);

//Method Chain Format
var loadAllData1 = DtContext.Cities.Where(d => d.CityName.StartsWith("C")).Take(10);

return PartialView(loadAllData);
}
</pre>
[/html]

We are ready to see our first query in action now.

Let’s creat a partial view now to show the data we fetched.

JOIN Query

To write a join, the query would be as preceding.

[csharp]
/// <summary>
/// Linq query with join and where
/// </summary>
/// <returns></returns>
public ActionResult JoinWithWhere()
{
var loadAllData = (from oOrders in DtContext.Orders
join oOrderLines in DtContext.OrderLines
on oOrders.OrderID equals oOrderLines.OrderID
orderby oOrders.OrderID
select new OrderAndOrderLines()
{
OrderId = oOrders.OrderID,
Description = oOrderLines.Description,
Quantity = oOrderLines.Quantity
}).Take(10);
//Method Chain Format
var asMethodChain = DtContext.Orders.Join(DtContext.OrderLines, oOrders => oOrders.OrderID,
oOrderLines => oOrderLines.OrderID,
(oOrders, oOrderLines) => new { oOrders, oOrderLines })
.OrderBy(@o => @o.oOrders.OrderID)
.Select(@s => new OrderAndOrderLines()
{
OrderId = @s.oOrders.OrderID,
Description = @s.oOrderLines.Description,
Quantity = @s.oOrderLines.Quantity
}).Take(10);

return PartialView(loadAllData);
}
[/csharp]

In the above query we are just joining the tables Order and OrderLines with OrderID and to select we are using an another custom model OrderAndOrderLines.

[csharp]
namespace LINQ_B_to_A.Models
{
public partial class OrderAndOrderLines
{
public int OrderId { get; set; }
public string Description { get; set; }
public int? Quantity { get; set; }
}
}
[/csharp]

The view can be written as follows.

[html]
@model IEnumerable<LINQ_B_to_A.Models.OrderAndOrderLines>
<style>
td, th, thead,pre {
border: 1px solid #ccc;
padding: 5px;
margin: 5px;
width: auto;
width: 20%;
}

caption {
background-color: #a9a9a9
}
pre {
width: auto;
}
</style>

<table>
<caption>Order Details</caption>
<tr>
<th>Order ID</th>
<th>Description</th>
<th>Quantity</th>
</tr>
@foreach (var @item in Model)
{
<tr>
<td>@item.OrderId</td>
<td>@item.Description</td>
<td>@item.Quantity</td>
</tr>
}
</table>
<pre>
public ActionResult JoinWithWhere()
{
var loadAllData = (from oOrders in DtContext.Orders
join oOrderLines in DtContext.OrderLines
on oOrders.OrderID equals oOrderLines.OrderID
orderby oOrders.OrderID
select new OrderAndOrderLines()
{
OrderId = oOrders.OrderID,
Description = oOrderLines.Description,
Quantity = oOrderLines.Quantity
}).Take(10);
//Method Chain Format
var asMethodChain = DtContext.Orders.Join(DtContext.OrderLines, oOrders => oOrders.OrderID,
oOrderLines => oOrderLines.OrderID,
(oOrders, oOrderLines) => new { oOrders, oOrderLines })
.OrderBy(o => o.oOrders.OrderID)
.Select(s => new OrderAndOrderLines()
{
OrderId = s.oOrders.OrderID,
Description = s.oOrderLines.Description,
Quantity = s.oOrderLines.Quantity
}).Take(10);

return PartialView(loadAllData);
}
</pre>
[/html]

Once you run the action you can see the result as follows.

LINQ Basic to Advanced Join With Where

Left JOIN Query

To write a Left join, the query would be as preceding.

[csharp]
/// <summary>
/// Linq query with Left Join
/// </summary>
/// <returns></returns>
public ActionResult LeftJoin()
{
var loadAllData = (from oOrder in DtContext.Orders
join oOrderLine in DtContext.OrderLines
on oOrder.OrderID equals oOrderLine.OrderID
into lftOrder
from afterJoined in lftOrder.DefaultIfEmpty()
orderby oOrder.OrderID descending
select new OrderAndOrderLines()
{
OrderId = oOrder.OrderID,
Description = afterJoined.Description
}).Take(10).ToList();
//Method Chain Format
var lftJoinMethodChain = (DtContext.Orders.GroupJoin(DtContext.OrderLines,
oOrder => oOrder.OrderID, oOrderLine => oOrderLine.OrderID,
(oOrder, lftJoin) => new { oOrder, lftJoin })
.SelectMany(@sm => @sm.lftJoin.DefaultIfEmpty(), (@sm, afterJoin) => new { @sm, afterJoin })
.OrderByDescending(@o => @o.sm.oOrder.OrderID)
.Select(@s => new OrderAndOrderLines()
{
OrderId = @s.sm.oOrder.OrderID,
Description = @s.afterJoin.Description
})).Take(10).ToList();

return PartialView(loadAllData);
}
[/csharp]

In the above query we are just joining the tables Order and OrderLines with OrderID and to select we are using an another custom model OrderAndOrderLines as our previous query. The differences you could find here are, using an ‘into’ and ‘DefaultIfEmpty’ statements. The DefaultIfEmpty is making sure that it returns empty if there is no appropriate rows found in the second table.

The view can be written as follows.

[html]
@model IEnumerable<LINQ_B_to_A.Models.OrderAndOrderLines>
<style>
td, th, thead, pre {
border: 1px solid #ccc;
padding: 5px;
margin: 5px;
width: auto;
width: 20%;
}

caption {
background-color: #a9a9a9
}
pre {
width: auto;
}
</style>

<table>
<caption>Order Details</caption>
<tr>
<th>Order ID</th>
<th>Description</th>
<th>Quantity</th>
</tr>
@foreach (var @item in Model)
{
<tr>
<td>@item.OrderId</td>
<td>@item.Description</td>
<td>@item.Quantity</td>
</tr>
}
</table>
<pre>
public ActionResult LeftJoin()
{
var loadAllData = (from oOrder in DtContext.Orders
join oOrderLine in DtContext.OrderLines
on oOrder.OrderID equals oOrderLine.OrderID
into lftOrder
from afterJoined in lftOrder.DefaultIfEmpty()
orderby oOrder.OrderID descending
select new OrderAndOrderLines()
{
OrderId = oOrder.OrderID,
Description = afterJoined.Description
}).Take(10).ToList();
//Method Chain Format
var lftJoinMethodChain = (DtContext.Orders.GroupJoin(DtContext.OrderLines,
oOrder => oOrder.OrderID, oOrderLine => oOrderLine.OrderID,
(oOrder, lftJoin) => new { oOrder, lftJoin })
.SelectMany(sm => sm.lftJoin.DefaultIfEmpty(), (sm, afterJoin) => new { sm, afterJoin })
.OrderByDescending(o => o.sm.oOrder.OrderID)
.Select(s => new OrderAndOrderLines()
{
OrderId = s.sm.oOrder.OrderID,
Description = s.afterJoin.Description
})).Take(10).ToList();

return PartialView(loadAllData);
}
</pre>
[/html]

Once you run the action you can see the result as follows.

LINQ Basic to Advanced Left Join

As you can see in the image, the order id 200000 doesn’t has any appropriate rows in the second table, so it shows as empty.

Distinct Query

The below query shows how we can write simple distinct query.

[csharp]
/// <summary>
/// Linq query Distinct sample
/// </summary>
/// <returns></returns>
public ActionResult DistinctSample()
{
var distictSample = (from oOrder in DtContext.OrderLines
select oOrder.Description).Distinct().Take(10).ToList();

//Method Chain Format
var distictAsMethodChain = (DtContext.OrderLines.Select(oOrder => oOrder.Description)).Distinct().Take(10).ToList();

return PartialView(distictSample);
}
[/csharp]

In the above query we use Distinct to make sure that only distict items are selected from the result. The view can be written as follows.

[html]
@model List<string>
<style>
dd, dt, pre {
border: 1px solid #ccc;
padding: 5px;
margin: 5px;
width: auto;
width: 20%;
}

dd {
background-color: #a9a9a9
}

pre {
width: auto;
}
</style>
<dd>Order Descriptions</dd>
@foreach (var orderLinesyObj in Model)
{
<dt>@orderLinesyObj</dt>
}
<pre>
public ActionResult DistinctSample()
{
var distictSample = (from oOrder in DtContext.OrderLines
select oOrder.Description).Distinct().Take(10).ToList();

//Method Chain Format
var distictAsMethodChain = (DtContext.OrderLines.Select(oOrder => oOrder.Description)).Distinct().Take(10).ToList();

return PartialView(distictSample);
}
</pre>
[/html]

Once you run the action you can see the result as follows.

LINQ Basic to Advanced Distinct Query

Equals and Not Equals Queries

We can write the equals and not equals query as preceding.

[csharp]
/// <summary>
/// Linq query Equals sample
/// </summary>
/// <returns></returns>
public ActionResult EqualsSamples()
{
var objEquals = (from objCity in DtContext.Cities
where objCity.CityName.Equals("Troy")
select objCity).Take(2);
//Method Chain Format
var objEquals1 = DtContext.Cities.Where(d => d.CityName.Equals("Troy")).Take(2);

return PartialView("OperatorSamples", objEquals);
}

/// <summary>
/// Linq query Not Equals sample
/// </summary>
/// <returns></returns>
public ActionResult NotEqualsSamples()
{
var objNotEquals = (from objCity in DtContext.Cities
where objCity.CityName != "Troy"
select objCity).Take(5);

var objNotEquals1 = (from objCity in DtContext.Cities
where !objCity.CityName.Equals("Troy")
select objCity).Take(5);

//Method Chain Format
var objNotEquals2 = DtContext.Cities.Where(d => d.CityName != "Troy").Take(2);

var objNotEquals3 = DtContext.Cities.Where(d => !d.CityName.Equals("Troy")).Take(2);

return PartialView("OperatorSamples", objNotEquals);
}
[/csharp]

The view can be written as follows.

[html]
@model IQueryable<LINQ_B_to_A.Models.City>
<style>
td, th, thead, pre {
border: 1px solid #ccc;
padding: 5px;
margin: 5px;
width: auto;
width: 20%;
}

caption {
background-color: #a9a9a9
}

pre {
width: auto;
}
</style>

<table>
<caption>City Details</caption>
<tr>
<th>City ID</th>
<th>City Name</th>
<th>City Location</th>
</tr>
@foreach (var @item in Model)
{
<tr>
<td>@item.CityID</td>
<td>@item.CityName</td>
<td>@item.Location</td>
</tr>
}
</table>
<caption>Equals Oerator</caption>
<pre>
public ActionResult EqualsSamples()
{
var objEquals = (from objCity in DtContext.Cities
where objCity.CityName.Equals("Troy")
select objCity).Take(2);
//Method Chain Format
var objEquals1 = DtContext.Cities.Where(d => d.CityName.Equals("Troy")).Take(2);

return PartialView("OperatorSamples", objEquals);
}

public ActionResult NotEqualsSamples()
{
var objNotEquals = (from objCity in DtContext.Cities
where objCity.CityName != "Troy"
select objCity).Take(5);

var objNotEquals1 = (from objCity in DtContext.Cities
where !objCity.CityName.Equals("Troy")
select objCity).Take(5);

//Method Chain Format
var objNotEquals2 = DtContext.Cities.Where(d => d.CityName != "Troy").Take(2);

var objNotEquals3 = DtContext.Cities.Where(d => !d.CityName.Equals("Troy")).Take(2);

return PartialView("OperatorSamples", objNotEquals);
}

public ActionResult PagingQueries()
{
var objNotEquals = (from objCity in DtContext.Cities
where objCity.CityName != "Troy"
orderby objCity.CityName ascending
select objCity).Skip(5).Take(5);

//Method Chain Format
var objNotEquals2 = DtContext.Cities.Where(d => d.CityName != "Troy").Skip(5).Take(5);

return PartialView("OperatorSamples", objNotEquals);
}
</pre>
[/html]

Once you run the action you can see the result as follows.

LINQ Basic to Advanced Equals and Not Equals

LINQ Paging Queries

Paging queries are always important as we work in some grid controls, with LINQ those are very easy. Let’s see one of that query.

[csharp]
/// <summary>
/// Linq Paging Queries
/// </summary>
/// <returns></returns>
public ActionResult PagingQueries()
{
var objNotEquals = (from objCity in DtContext.Cities
where objCity.CityName != "Troy"
orderby objCity.CityName ascending
select objCity).Skip(5).Take(5);

//Method Chain Format
var objNotEquals2 = DtContext.Cities.Where(d => d.CityName != "Troy").Skip(5).Take(5);

return PartialView("OperatorSamples", objNotEquals);
}
[/csharp]

Once you run the action you can see the result as follows.

LINQ Basic to Advanced Paging Queries

LINQ Math Queries

Here we are going to write the possible Math functions in our LINQ query.

[csharp]
/// <summary>
/// Math Queries
/// </summary>
/// <returns></returns>
public ActionResult MathQueries()
{
var objMath = (from objInv in DtContext.InvoiceLines
where objInv.ExtendedPrice > 10 && objInv.Quantity < 15
orderby objInv.InvoiceLineID descending
select new MathClass()
{
Actual = objInv.ExtendedPrice,
Round = Math.Round(objInv.ExtendedPrice),
Floor = Math.Floor(objInv.ExtendedPrice),
Ceiling = Math.Ceiling(objInv.ExtendedPrice),
Abs = Math.Abs(objInv.ExtendedPrice)
}).Take(10);

//Method Chain Format
var objMath2 = DtContext.InvoiceLines
.Where(objInv => objInv.ExtendedPrice > 10 && objInv.Quantity < 15)
.OrderByDescending(o => o.InvoiceLineID)
.Select(objInv => new MathClass()
{
Actual = objInv.ExtendedPrice,
Round = Math.Round(objInv.ExtendedPrice),
Floor = Math.Floor(objInv.ExtendedPrice),
Ceiling = Math.Ceiling(objInv.ExtendedPrice),
Abs = Math.Abs(objInv.ExtendedPrice)
}).Take(10);

return PartialView("MathQueries", objMath);
}
[/csharp]

As you can see we have written most of the possible Math functions in our query and selecting with a custome model MathClass.

[csharp]
namespace LINQ_B_to_A.Models
{
public partial class MathClass
{
public decimal Actual { get; set; }
public decimal Round { get; set; }
public decimal Floor { get; set; }
public decimal Ceiling { get; set; }
public decimal Abs { get; set; }
}
}
[/csharp]

Let’s see the view now.

[html]

@model IQueryable<LINQ_B_to_A.Models.MathClass>
<style>
td, th, thead, pre {
border: 1px solid #ccc;
padding: 5px;
margin: 5px;
width: auto;
width: 20%;
}

caption {
background-color: #a9a9a9
}

pre {
width: auto;
}
</style>

<table>
<caption>Math Operators</caption>
<tr>

</tr>
@foreach (var @item in Model)
{
<tr>
<td>Actual: @item.Actual</td>
<td>Round: @item.Round</td>
<td>Floor: @item.Floor</td>
<td>Ceiling: @item.Ceiling</td>
<td>Abs: @item.Abs</td>
</tr>
}
</table>
<pre>
public ActionResult MathQueries()
{
var objMath = (from objInv in DtContext.InvoiceLines
where objInv.ExtendedPrice > 10 && objInv.Quantity < 15
orderby objInv.InvoiceLineID descending
select new MathClass()
{
Actual = objInv.ExtendedPrice,
Round = Math.Round(objInv.ExtendedPrice),
Floor = Math.Floor(objInv.ExtendedPrice),
Ceiling = Math.Ceiling(objInv.ExtendedPrice),
Abs = Math.Abs(objInv.ExtendedPrice)
}).Take(10);

//Method Chain Format
var objMath2 = DtContext.InvoiceLines
.Where(objInv => objInv.ExtendedPrice > 10 && objInv.Quantity < 15)
.OrderByDescending(o => o.InvoiceLineID)
.Select(objInv => new MathClass()
{
Actual = objInv.ExtendedPrice,
Round = Math.Round(objInv.ExtendedPrice),
Floor = Math.Floor(objInv.ExtendedPrice),
Ceiling = Math.Ceiling(objInv.ExtendedPrice),
Abs = Math.Abs(objInv.ExtendedPrice)
}).Take(10);

return PartialView("MathQueries", objMath);
}
</pre>
[/html]

See the result now.

LINQ Basic to Advanced Math Queries

LINQ String Queries

As we saw the Math queries, here we are going to write the possible String functions in our LINQ query.

[csharp]
/// <summary>
/// String Queries
/// </summary>
/// <returns></returns>
public ActionResult StringQueries()
{
var objString = (from objInv in DtContext.InvoiceLines
where objInv.ExtendedPrice > 10 && objInv.Quantity < 15
orderby objInv.InvoiceLineID descending
select new StringClass()
{
Actual = objInv.Description,
Insert = objInv.Description.Insert(2, "sibeeshpassion"),
Remove = objInv.Description.Remove(1, 1),
Substring = objInv.Description.Substring(2, 3),
ToLower = objInv.Description.ToLower(),
ToUpper = objInv.Description.ToUpper(),
TrimEnd = objInv.Description.TrimEnd(),
TrimStart = objInv.Description.TrimStart()
}).Take(2);

//Method Chain Format
var objString2 = DtContext.InvoiceLines
.Where(objInv => objInv.ExtendedPrice > 10 && objInv.Quantity < 15)
.OrderByDescending(o => o.InvoiceLineID)
.Select(objInv => new StringClass()
{
Actual = objInv.Description,
Insert = objInv.Description.Insert(2, "sibeeshpassion"),
Remove = objInv.Description.Remove(1, 1),
Substring = objInv.Description.Substring(2, 3),
ToLower = objInv.Description.ToLower(),
ToUpper = objInv.Description.ToUpper(),
TrimEnd = objInv.Description.TrimEnd(),
TrimStart = objInv.Description.TrimStart()
}).Take(2);

return PartialView("StringQueries", objString);
}
[/csharp]

As you can see, here we are using a custom model StringClass.

[csharp]
namespace LINQ_B_to_A.Models
{
public partial class StringClass
{
public string Actual { get; set; }
public string Insert { get; set; }
public string Remove { get; set; }
public string Substring { get; set; }
public string ToUpper { get; set; }
public string ToLower { get; set; }
public string TrimStart { get; set; }
public string TrimEnd { get; set; }
}
}
[/csharp]

Let’s see the view now.

[html]

@model IQueryable<LINQ_B_to_A.Models.StringClass>
<style>
td, th, thead, pre {
border: 1px solid #ccc;
padding: 5px;
margin: 5px;
width: auto;
width: 20%;
}

caption {
background-color: #a9a9a9
}

pre {
width: auto;
}
</style>

<table>
<caption>String Operators</caption>
<tr>

</tr>
@foreach (var @item in Model)
{
<tr>
<td>Actual: @item.Actual</td>
<td>Insert: @item.Insert</td>
<td>Remove: @item.Remove</td>
<td>Substring: @item.Substring</td>
<td>ToLower: @item.ToLower</td>
<td>ToUpper: @item.ToUpper</td>
<td>TrimEnd: @item.TrimEnd</td>
<td>TrimStart: @item.TrimStart</td>
</tr>
}
</table>
<pre>
public ActionResult StringQueries()
{
var objString = (from objInv in DtContext.InvoiceLines
where objInv.ExtendedPrice > 10 && objInv.Quantity < 15
orderby objInv.InvoiceLineID descending
select new StringClass()
{

Actual = objInv.Description,
Insert = objInv.Description.Insert(2,"sibeeshpassion"),
Remove = objInv.Description.Remove(1,1),
Substring = objInv.Description.Substring(2,3),
ToLower = objInv.Description.ToLower(),
ToUpper = objInv.Description.ToUpper(),
TrimEnd = objInv.Description.TrimEnd(),
TrimStart = objInv.Description.TrimStart()
}).Take(2);

//Method Chain Format
var objString2 = DtContext.InvoiceLines
.Where(objInv => objInv.ExtendedPrice > 10 && objInv.Quantity < 15)
.OrderByDescending(o => o.InvoiceLineID)
.Select(objInv => new StringClass()
{
Actual = objInv.Description,
Insert = objInv.Description.Insert(2, "sibeeshpassion"),
Remove = objInv.Description.Remove(1, 1),
Substring = objInv.Description.Substring(2, 3),
ToLower = objInv.Description.ToLower(),
ToUpper = objInv.Description.ToUpper(),
TrimEnd = objInv.Description.TrimEnd(),
TrimStart = objInv.Description.TrimStart()
}).Take(2);

return PartialView("StringQueries", objString);
}
</pre>
[/html]

Now see the result.

LINQ Basic to Advanced String Queries

SelectMany Query

A SelectMany query flattern the result to a single dimentional collection, so to loop through the result we just need only one loop.

LINQ Basic to Advanced SelectMany Tooltip

If you use the normal Select, you will be getting a list of lists, thus you will have to use two loops to get the datas.

LINQ Basic to Advanced Select Tooltip

[csharp]
/// <summary>
/// Linq query with SelectMany
/// </summary>
/// <returns></returns>
public ActionResult SelectMany()
{
var selectMany = DtContext.Orders.SelectMany(order => order.Invoices).Take(10);
var select = DtContext.Orders.Select(order => order.Invoices).Take(10);
return PartialView("SelectMany", selectMany);
}
[/csharp]

Let’s see the view now.

[html]
@model IQueryable<LINQ_B_to_A.Models.Invoice>
<style>
td, th, thead, pre {
border: 1px solid #ccc;
padding: 5px;
margin: 5px;
width: auto;
width: 20%;
}

caption {
background-color: #a9a9a9
}

pre {
width: auto;
}
</style>

<table>
<caption>Invoice Details</caption>
<tr>
<th>Order ID</th>
<th>Invoice ID</th>
<th>Invoice Date</th>
</tr>
@foreach (var @item in Model)
{
<tr>
<td>@item.OrderID</td>
<td>@item.InvoiceID</td>
<td>@item.InvoiceDate</td>
</tr>
}
</table>
<caption>Select Many</caption>
<pre>
/// <summary>
/// Linq query with SelectMany
/// </summary>
/// <returns></returns>
public ActionResult SelectMany()
{
var selectMany = DtContext.Orders.SelectMany(order => order.Invoices).Take(10);
var select = DtContext.Orders.Select(order => order.Invoices).Take(10);
return PartialView("SelectMany", selectMany);
}
</pre>
[/html]

Now see the result.

That’s all for today, I will come with another set of LINQ queries in the next part. Till then, bye.

LINQ Basic to Advanced SelectMany

Conclusion

Did I miss anything that you may think which is needed? Could you find this post as useful? I hope you liked this article. Please share me your valuable suggestions and feedback.

Your turn. What do you think?

A blog isn’t a blog without comments, but do try to stay on topic. If you have a question unrelated to this post, you’re better off posting it on C# Corner, Code Project, Stack Overflow, Asp.Net Forum instead of commenting here. Tweet or email me a link to your question there and I’ll definitely try to help if I can.

Kindest Regards
Sibeesh Venu

Introduction

Here, in this post we are going to a see how we can install Asp.Net Core Docker in our Windows. Before we start, it would be useful if we say something about the Docker right? Docker is a container software platform where container is everything we need to make our software run. The container is light in weight. You can read more about the Docker here. I hope you will like this. Now let’s begin.

Background

Today, I was just trying to create a Asp.Net Docker application in Visual Studio 2017. Unfortunately I was getting an error as preceding.

Error MSB4018 The “PrepareForBuild” task failed unexpectedly.
Microsoft.DotNet.Docker.CommandLineClientException: Unable to run ‘docker-compose’. Verify that Docker for Windows is installed and running locally. For troubleshooting, please review http://aka.ms/DockerToolsTroubleshooting. —> System.ComponentModel.Win32Exception: The system cannot find the file specified

Then I came to know that I have not installed Docker in my machine yet, so I decided to do that.

Asp Net Core Docker Error

Installing Docker For Windows

You can install the Docker from here. Once you downloaded the set up file, please run the file.

Docker For Windows

Start and test the Docker

Once you installed the Docker, now it is time to test whether everything is installed correctly or not. Before that make sure that the Docker is starting.

Docker is Starting

There is a hight possibility that to get an error “Hardware assisted virtulization and data execution protection must be enabled in the BIOS” as preceding image.

Docker Error

Before you go and change the settings in BIOS, check in Task Manager window as well.

Hyper V support and Virtulization

Enabling Virtulization in BIOS

To Enable the Virtulization in BIOS, go to System Configuration -> Click on Virtulization Technology and Enable it.

BIOS Settings

After the restart, the Docker will ask you to start the service. Go ahead and do that.

Setting up Docker

Docker Service Is Not Runnig Window

Now again, if you are getting an error as “Error MSB4018 The “PrepareForLaunch” task failed unexpectedly.
Microsoft.DotNet.Docker.CommandLineClientException: Creating network “dockercompose3875147227_default” with the default driver
Building linq_basic_to_advanced Service ‘linq_basic_to_advanced’ failed to build: Get https://registry-1.docker.io/v2/: net/http: request canceled while waiting for connection (Client.Timeout exceeded while awaiting headers).”, you need to change your shared drive settings in Docker.

Right click and click on the settings.

Docker Settings

Click on the Shared Drives and  select the drive that hosts your project and the drive where %USERPROFILE% resides.

Shared Drive in Docker

Click on Apply and type your filesystem passwor in the following pop up. Now if you are running the Edge version of Docker Community Edition for Windows, after the install you may be able to login with your Docker ID and password.

Docker SignIn page

We have enough settings for now, shall we just check whether the installation is done perfectly or not? To check, go to the command window and type the command as  docker run hello-world.

Docker Check From Command Window

You can also check the Docker version with the command docker –version

Conclusion

Did I miss anything that you may think which is needed? Could you find this post as useful? I hope you liked this article. Please share me your valuable suggestions and feedback.

Your turn. What do you think?

A blog isn’t a blog without comments, but do try to stay on topic. If you have a question unrelated to this post, you’re better off posting it on C# Corner, Code Project, Stack Overflow, Asp.Net Forum instead of commenting here. Tweet or email me a link to your question there and I’ll definitely try to help if I can.

Kindest Regards
Sibeesh Venu