Task and Thread in c#

 

In C#, threads and tasks are both used for asynchronous programming and parallel execution, but they serve different purposes and provide different levels of abstraction and control. Let's explore the differences between them:

Threads

1. Low-Level Concept:

   • A thread is the basic unit of execution within a process.

   • It represents a separate path of execution in the application.

2. Creation:

   • Threads can be created and managed using the System.Threading.Thread class.

   • Example:

     csharp

     using System;
     using System.Threading;
     
     class Program
     {
         static void Main()
         {
             Thread thread = new Thread(new ThreadStart(DoWork));
             thread.Start();
         }
     
         static void DoWork()
         {
             Console.WriteLine("Work on a separate thread");
         }
     }
     

3. Control:

   • You have fine-grained control over the thread’s lifecycle (e.g., start, sleep, join, abort).

   • Example:

     csharp

     thread.Join(); // Wait for the thread to finish

4. State Management:

   • Requires manual state management and synchronization (e.g., using locks, mutexes).

Tasks

1. High-Level Abstraction:

   • A task is a higher-level abstraction provided by the Task Parallel Library (TPL) in the System.Threading.Tasks namespace.

   • It represents an asynchronous operation and is designed to simplify writing concurrent code.

2. Creation:

   • Tasks can be created using the Task class.

   • Example:

     csharp

     using System;
     using System.Threading.Tasks;
     
     class Program
     {
         static async Task Main()
         {
             Task task = Task.Run(() => DoWork());
             await task;
         }
     
         static void DoWork()
         {
             Console.WriteLine("Work on a separate task");
         }
     }
     

3. Control:

   • Tasks are easier to manage, with built-in support for continuations and cancellation.

   • Example:

     csharp

     Task task = Task.Run(() => DoWork());
     task.Wait(); // Wait for the task to finish

4. State Management:

   • The TPL provides built-in mechanisms for state management and synchronization, reducing the complexity of concurrent programming.

Key Differences

Feature	Thread	Task
Abstraction Level	Low-level	High-level
Namespace	System.Threading	System.Threading.Tasks
Creation	new Thread(...)	Task.Run(...), Task.Factory.StartNew(...)
Control	Start, Sleep, Join, Abort	Wait, ContinueWith, CancellationToken
State Management	Manual synchronization required	Built-in support for synchronization and continuations
Use Case	Fine-grained control needed	Simplified asynchronous programming, parallelism

Summary

• Threads: Lower-level, more control, requires manual synchronization, used for precise thread management.

• Tasks: Higher-level abstraction, easier to use, built-in support for synchronization and continuation, ideal for parallelism and asynchronous programming.

Using tasks is generally recommended for modern C# programming because they are easier to manage and provide more features for handling asynchronous operations efficiently. 

simple use of Record in c#9 and newer versions

 c# 9 introduces a new keyword Record which makes an object immutable. Properties in the record can be initialised at the time of creation or constructor call only. Record can be written like how we write a class. It has same syntax as class.

For example:

public record Friend

        {

            public Friend()

            {

            }

            public Friend(string name, string surname)

            {

                this.Name = name;

                this.Surname = surname;

            }

            public string Name { get; init; }

            public string Surname { get; init; }

        }

use of Friend record:

var newFriend = new Friend("Tom", "Pandey");

//--Note: we called here using constructor.

var newFriend1 = new Friend{Name="Tom",Surname= "Pandey"};

//Note: this calls the constructor without parameter. constructor without parameter is not required to to call to initiate the record. 

This record is equivalent to below code which don't have a constructor:

public record Friend

        {

            public string Name { get; init; }

            public string Surname { get; init; }

        }

use of Friend Record:

var newFriend = new Friend("Tom", "Pandey");

Note: we called here using constructor, but we don't have constructor defined. so It will throw an error. Instead we create object friend like this:

var newFriend1 = new Friend{Name="Tom",Surname= "Pandey"};

In both the example of Record, we can not modify the property Name or Surname after the object is created. 

The Friend record with constructor can be written as below code in one line:

public record Friend(String Name, String Surname);

use of Friend Record: 

Friend friend = new Friend("John","Pandey" );

Note: since this is constructor type record, we must create record object using constructor.for example below code will throw error:

var newFriend1 = new Friend{Name="Tom",Surname= "Pandey"};

On compilation, this is converted to class with immutable properties.

init only property in c#9 or later versions

 c# 9 introduces new Init-Only property that allow to make immutable properties in a class. This means the property with "init" keyword in place of "set" keyword allows the property to be initialized at the construction step of an object. it doesn't allow you to set the value later, once the object is initialised. 

For example

 public class Friend

        {

            public Friend(string name, string surname)

            {

                this.Name = name;

                this.Surname = surname;

            }

            public string Name { get; init; }

            public string Surname { get; init; }

        }

Use of Friend

   public void SomeMethod()

        {

            Friend friend = new Friend("John", "Sharma");

            var newFriend = new Friend("Tom", "Pandey");

        }

Use of init property after initialization throws an error. for eg.

 public void SomeMethod()

        {

            Friend friend = new Friend("John", "Sharma");

            var newFriend = new Friend("Tom", "Pandey");

            friend.Surname = "xxx"; //<--- Error here.

        }

Unit test c#: Create Fake Httpcontext to bypass Null exception for User object

 Microsoft Visual studio Test Framework

Requirement: Nuget package Moq 4.13.0.0 (or later)

Settings in visual studio: Menu->Tools->Options ->Debugging->General

Tick "Use Managed Compatibility Mode"

Code: (copied from stackoverflow)

Step 1: 

Create a new class FakeHttpContext and paste the below code. Change the Returns value to whatever user name you need.

public static class FakeHttpContext

    {

        public static void SetFakeContext(this Controller controller)

        {

            var httpContext = MakeFakeContext();

            ControllerContext context =

            new ControllerContext(

            new RequestContext(httpContext,

            new RouteData()), controller);

            controller.ControllerContext = context;

        }

        private static HttpContextBase MakeFakeContext()

        {

            var context = new Mock<HttpContextBase>();

            var request = new Mock<HttpRequestBase>();

            var response = new Mock<HttpResponseBase>();

            var session = new Mock<HttpSessionStateBase>();

            var server = new Mock<HttpServerUtilityBase>();

            var user = new Mock<IPrincipal>();

            var identity = new Mock<IIdentity>();

            context.Setup(c => c.Request).Returns(request.Object);

            context.Setup(c => c.Response).Returns(response.Object);

            context.Setup(c => c.Session).Returns(session.Object);

            context.Setup(c => c.Server).Returns(server.Object);

            context.Setup(c => c.User).Returns(user.Object);

            user.Setup(c => c.Identity).Returns(identity.Object);

            identity.Setup(i => i.IsAuthenticated).Returns(true);

            identity.Setup(i => i.Name).Returns("sanjeeb");

            return context.Object;

        }

    }

Step 2: 

Initialize the Fakehttpcontext in test initialize function. 

FakeHttpContext.SetFakeContext(usersController);

Entity Framework Core with Existing Database

Entity Framework Core only supports code first database aproach. 
To use existing database, we'll need to reverse Engineer Model from existing Database. 

• Open Visual studio.
• Menu > tools >Nuget Package Manager >
• open PM Console

Note: All the tables in the database must have Primary key defined. else you'll get error like:
Unable to generate entity type for table 'dbo.xOrdersMBS'.
Unable to identify the primary key for table 'dbo.xActivePricesEPB'.
Unable to generate entity type for table 'dbo.xActivePricesEPB'.
Unable to identify the primary key for table 'dbo.xLeadTimePBOM'.
Unable to generate entity type for table 'dbo.xLeadTimePBOM'.


 In the console, run the below power shell commands:

Using Windows Authentication:
Scaffold-DbContext "Server=DatabaseServerAddress;Database=DatabaseName;Trusted_Connection=True;" Microsoft.EntityFrameworkCore.SqlServer -OutputDir Models -f

Using SQL Account:

Scaffold-DbContext "data source=DatabaseServerAddress;initial catalog=DatabaseName;uid=UserName;pwd=Password;" Microsoft.EntityFrameworkCore.SqlServer -OutputDir Models -f

Note: -f force create the files if the file exist in the folder Models.

Add nuget packages to Artifacts in Azure devops

download latest nuget.exe from the nuget site. (google it)

copy the nuget.exe in d: (any location is fine)

Use visual studio -> Package manager console. 

run the below command

D:\nuget.exe push -Source "IGTelerikFeed" -ApiKey az D:\Telerik.UI.for.AspNet.Core.2020.2.617.nupkg

[Note: It will ask Credential to connect to the devops when you press enter. ]

EntityFramework Insert error due to PrimaryKey

MyProject.Controllers.CurrencyCodesController Unable to update the EntitySet 'CurrencyCodes' because it has a DefiningQuery and no <InsertFunction> element exists in the <ModificationFunctionMapping> element to support the current operation. System.Data.Entity.Infrastructure.DbUpdateException: Unable to update the EntitySet 'CurrencyCodes' because it has a DefiningQuery and no <InsertFunction> element exists in the <ModificationFunctionMapping> element to support the current operation. ---> System.Data.Entity.Core.UpdateException: Unable to update the EntitySet 'CurrencyCodes' because it has a DefiningQuery and no <InsertFunction> element exists in the <ModificationFunctionMapping> element to support the current operation.

​ Scenario:  The error occured while trying to insert the currencycodes entity to the database.  [HttpPost] [ValidateAntiForgeryToken] public ActionResult Create([Bind(Include = "cucCurrencyCode,cucDescription,cucMultiplier,cucRate,cucInUse")] CurrencyCode currencyCode) { if (ModelState.IsValid) { try { db.CurrencyCodes.Add(currencyCode); db.SaveChanges(); } catch (Exception ex) { log.Error(ex.Message, ex); } return RedirectToAction("Index"); } return View(currencyCode); } Solution:  1) Check Primary key in .edmx file.  In my case cucInUse was set as Entity key. I removed it. 2) Now Right click the .edmx file and click "Open with...". Select XML (text) Editor 3)  Find the element <EntitySet name = "CurrencyCodes"...> 4) Change store:Schema="dbo" => Schema="dbo" 5) delete element <DefiningQuery> 6) Clean the project.  7) close Visual studio. 8) Open visual studio. Open the project.  9) Clean and build the project.  10) Run the application.

Use log4net for all logging in c# application

Exception logging is hugely important within an application, not just to ensure we know when an error has occured but also to help use trace back the thread to help investigate where the error originated.

Our strategy is to use log4net for all our logging needs.

This page helps cover the follow areas

1. Setting up logging across the entire applications

2. Including 2 appenders so we can be notified when they occur and ensure a tracable debug log file is available.

Setting up your Applications for Logging

Reference log4net in your applications

in Global.asax under the start_application method include the following

    void Application_Start(object sender, EventArgs e)
    {
        // link up log4net configuration
        log4net.Config.XmlConfigurator.Configure();
    }

On the page where you wish to log information declare a new static variable in the class header

log4net.ILog log = log4net.LogManager.GetLogger(System.Reflection.MethodBase.GetCurrentMethod().DeclaringType);

Whenever you wish to now log an event in this class run one of the follow commands, ensure you include the exception when needed

log.Error("An unhandled exception occured", ex);

To ensure you catch all unhandled exceptions include the following in your Global.asax file. Remember to declare the log variable in the class too.

    void Application_Error(object sender, EventArgs e) 
    {
        // Code that runs when an unhandled error occurs
        // get last exception
        Exception ex = Server.GetLastError().GetBaseException();
        // log it
        log.Error("An unhandled exception occured", ex);
    }

Web.Config Settings

  <configSections>
    <section name="log4net" type="log4net.Config.Log4NetConfigurationSectionHandler, log4net"/>
  </configSections>

<log4net>
    <!-- The DebugFileAppender writes all messages to a log file-->
    <appender name="DebugFileAppender" type="log4net.Appender.RollingFileAppender">
      <file value="L:\[APPNAME]\Log.txt" /> <!-- These should be located on the "L" drive (if available) and stored under a folder named for the specific application -->      <datePattern value="'ApplicationLog.'yyyy-MM-dd'.txt'" />
      <staticLogFileName value="false" />
      <rollingStyle value="Composite" />
      <maxSizeRollBackups value="10" />
      <maximumFileSize value="5MB" />
      <appendToFile value="true" />
      <layout type="log4net.Layout.PatternLayout">
        <conversionPattern value="%d [%t] %-5p %c %m%n" />
      </layout>
    </appender>    <!-- The EmailAppender sends an email when something matches the filters-->
    <appender name="EmailAppender" type="log4net.Appender.SmtpAppender">
      <evaluator type="log4net.Core.LevelEvaluator">
        <threshold value="DEBUG"/>
      </evaluator>
      <!--  The filters are processed in order:
            1) match the Inserted New User message
            2) match any WARN or higher messages
            3) reject everything else -->
      <filter type="log4net.Filter.StringMatchFilter">
        <stringToMatch value="Inserted a new user" />
        <acceptOnMatch value="true" />
      </filter>
      <filter type="log4net.Filter.LevelRangeFilter">
        <levelMin value="WARN" />
        <acceptOnMatch value="true" />
      </filter>
      <filter type="log4net.Filter.DenyAllFilter" />
      <!--  The SmtpAppender authenticates against the mail server, the buffersize of 10 provides 10 lines
            of context when an error happens. -->
      <subject value="[SEVERITY] [ENV] [APPNAME] - [EXCP_MSG]" />
      <to value="itteam@site.com" />
      <from value="noreply@site.com" />
      <smtpHost value="smtpmail.lu.sii.com" />
      <bufferSize value="10" />
      <lossy value="true" />
      <layout type="log4net.Layout.PatternLayout">
        <param name="ConversionPattern" value="%d [%t] %-5p %c %m%n" />
      </layout>
    </appender>
    <appender name="EventLogAppender" type="log4net.Appender.EventLogAppender" >
      <applicationName value="MyApp" />


     <layout type="log4net.Layout.PatternLayout">


        <conversionPattern value="%date [%thread] %-5level %logger [%property{NDC}] - %message%newline" />


      </layout>


    </appender>

    <root>
      <!-- add other appenders here and the log messages will be sent to every listed appender -->
      <appender-ref ref="DebugFileAppender" />
      <appender-ref ref="EmailAppender" />
    </root>
  </log4net>

Create XML from class or Object in C-Sharp

function to serialize object to xml in c#

public static string SerializeObjectToXML(object item)
        {
            try
            {
                string xmlText;
                Type objectType = item.GetType();
                XmlSerializer xmlSerializer = new XmlSerializer(objectType);
                MemoryStream memoryStream = new MemoryStream();
                using (XmlTextWriter xmlTextWriter =
                    new XmlTextWriter(memoryStream, Encoding.UTF8) { Formatting = Formatting.Indented })
                {
                    xmlSerializer.Serialize(xmlTextWriter, item);
                    memoryStream = (MemoryStream)xmlTextWriter.BaseStream;
                    xmlText = new UTF8Encoding().GetString(memoryStream.ToArray());
                    memoryStream.Dispose();
                    return xmlText;
                }
            }
            catch (Exception e)
            {
                System.Diagnostics.Debug.Write(e.ToString());
                return null;
            }
        }