JALIYA'S BLOG: APRIL 2021 The general recommendation is Processors should be the go-to tool for writing applications that receive messages from Service Bus entities.The Receivers are recommended for more complex scenarios in which the processor is not able to provide the fine-grained control that one can expect when using the Receiver directly. Azure Functions use Processors, so obviously, that's my go-to option. JALIYA'S BLOG: AZURE SERVICE BUS: HANDLING FIFO USING SESSIONS In this post, let's see what Sessions are in Azure Service Bus. The primary use of Sessions (Groups) is to maintain FIFO when there are multiple receivers listening to JALIYA'S BLOG: WPF: EXTERNAL LOGIN WITH IDENTITY SERVER .NET, .NET Core, ASP.NET, ASP.NET Core, Visual Studio, Jaliya

Udagedara

AZURE SERVICE BUS CLIENT LIBRARY FOR .NET: RECEIVERS VS The general recommendation is Processors should be the go-to tool for writing applications that receive messages from Service Bus entities.The Receivers are recommended for more complex scenarios in which the processor is not able to provide the fine-grained control that one can expect when using the Receiver directly. Azure Functions use Processors, so obviously, that's my go-to option. JALIYA'S BLOG: AZURE PIPELINES: PASSING VARIABLES BETWEEN Here, I have 2 Stages, Build and Deployment. Build stage has 2 jobs, ; In the FirstJob, I am creating a variable called myVariable.I am making it an output variable and setting its value to Hello World.; In the SecondJob, ; The SecondJob is depending on FirstJob because the variable needs to be created first.; Then I am declaring a variable called myJobVariable and mapping it with myVariable JALIYA'S BLOG: USING OBJECTSTATEMANAGER FOR OBJECT Let’s jump into action by creating a console application and installing Entity Framework nuget package (I am installing installing the latest as of today which is 6.1.2) the project.In this application, I am going create a code-first sample database with three POCO entity types which are “Department”, “Hobby” and “Person”.I am modeling the entities and their relationships as

follows.

JALIYA'S BLOG: RETRYOPTIONS IN AZURE DURABLE FUNCTIONS So here, if MyActvity throws an exception of type MyException, we will be retrying again in 10 seconds and maxNumberOfAttempts will be 3.One of the important things to note for the Handle delegate is, you need access exceptions' InnerException if you want to get the actual

exception.

JALIYA'S BLOG: AZURE DURABLE FUNCTIONS AND EXTERNAL EVENTS In this post, let's see how we can make use of Azure Durable Functions with its External Event listening feature. This post assumes you have a basic understanding Durable Functions.. Let's consider the following

scenario.

JALIYA'S BLOG: EF CORE 5.0: MANY TO MANY RELATIONSHIPS One of the nicest features available in EF Core 5.0 is now you can define a many-to-many relationship without explicitly mapping the join

table.

JALIYA'S BLOG: C# 8.0: NOTNULL GENERIC CONSTRAINT A couple of months back I wrote a post about C# 8.0: Nullable Reference Types which is a feature coming with C# 8.0. A few days back Microsoft has released .NET Core 3.0 Preview 8. And from .NET Core 3.0 Preview 7 onwards, C# 8.0 is now considered feature complete. JALIYA'S BLOG: APRIL 2021 The general recommendation is Processors should be the go-to tool for writing applications that receive messages from Service Bus entities.The Receivers are recommended for more complex scenarios in which the processor is not able to provide the fine-grained control that one can expect when using the Receiver directly. Azure Functions use Processors, so obviously, that's my go-to option. JALIYA'S BLOG: AZURE SERVICE BUS: HANDLING FIFO USING SESSIONS In this post, let's see what Sessions are in Azure Service Bus. The primary use of Sessions (Groups) is to maintain FIFO when there are multiple receivers listening to JALIYA'S BLOG: WPF: EXTERNAL LOGIN WITH IDENTITY SERVER .NET, .NET Core, ASP.NET, ASP.NET Core, Visual Studio, Jaliya

Udagedara

AZURE SERVICE BUS CLIENT LIBRARY FOR .NET: RECEIVERS VS The general recommendation is Processors should be the go-to tool for writing applications that receive messages from Service Bus entities.The Receivers are recommended for more complex scenarios in which the processor is not able to provide the fine-grained control that one can expect when using the Receiver directly. Azure Functions use Processors, so obviously, that's my go-to option. JALIYA'S BLOG: AZURE PIPELINES: PASSING VARIABLES BETWEEN Here, I have 2 Stages, Build and Deployment. Build stage has 2 jobs, ; In the FirstJob, I am creating a variable called myVariable.I am making it an output variable and setting its value to Hello World.; In the SecondJob, ; The SecondJob is depending on FirstJob because the variable needs to be created first.; Then I am declaring a variable called myJobVariable and mapping it with myVariable JALIYA'S BLOG: USING OBJECTSTATEMANAGER FOR OBJECT Let’s jump into action by creating a console application and installing Entity Framework nuget package (I am installing installing the latest as of today which is 6.1.2) the project.In this application, I am going create a code-first sample database with three POCO entity types which are “Department”, “Hobby” and “Person”.I am modeling the entities and their relationships as

follows.

JALIYA'S BLOG: RETRYOPTIONS IN AZURE DURABLE FUNCTIONS So here, if MyActvity throws an exception of type MyException, we will be retrying again in 10 seconds and maxNumberOfAttempts will be 3.One of the important things to note for the Handle delegate is, you need access exceptions' InnerException if you want to get the actual

exception.

JALIYA'S BLOG: AZURE DURABLE FUNCTIONS AND EXTERNAL EVENTS In this post, let's see how we can make use of Azure Durable Functions with its External Event listening feature. This post assumes you have a basic understanding Durable Functions.. Let's consider the following

scenario.

JALIYA'S BLOG: EF CORE 5.0: MANY TO MANY RELATIONSHIPS One of the nicest features available in EF Core 5.0 is now you can define a many-to-many relationship without explicitly mapping the join

table.

JALIYA'S BLOG: C# 8.0: NOTNULL GENERIC CONSTRAINT A couple of months back I wrote a post about C# 8.0: Nullable Reference Types which is a feature coming with C# 8.0. A few days back Microsoft has released .NET Core 3.0 Preview 8. And from .NET Core 3.0 Preview 7 onwards, C# 8.0 is now considered feature complete. JALIYA'S BLOG: AZURE SERVICE BUS: HANDLING FIFO USING SESSIONS Note: Sessions are available only in the Standard and Premium tiers of Service Bus. And once sessions are enabled for an entity (Queue/Subscription), that specific entity can only receive messages that have the SessionId set to a valid value. JALIYA'S BLOG: USING OBJECTSTATEMANAGER FOR OBJECT Let’s jump into action by creating a console application and installing Entity Framework nuget package (I am installing installing the latest as of today which is 6.1.2) the project.In this application, I am going create a code-first sample database with three POCO entity types which are “Department”, “Hobby” and “Person”.I am modeling the entities and their relationships as

follows.

JALIYA'S BLOG: AZURE PIPELINES: CREATE/UPDATE AZURE API Products; Since I have already created a product in the APIM, I can just enter the name of the Product. If you are creating the Product as part of the pipeline (using API Management - Create or update product task), then you need to select Product created by previous task. OpenAPI Specification JALIYA'S BLOG: EF CORE: USING HILO ALGORITHM TO GENERATE IDS This will return 1, and the category will be assigned the value of 1 and it has now blocked Ids from 1 to 10. If we add in another category in the same database context, EF won't run the above query again, it will increment the Id by 1 and when we have added 10 categories, EF will run the above query again to get the next value, which will be

11.

JALIYA'S BLOG: EF CORE: OWNED ENTITY TYPES Note: I am using anotherContext here for retrieval, because EF Core will automatically fix-up navigation properties to any other entities that were previously loaded into the context instance. So even if you don't explicitly include the data for a navigation property, the property may still be populated if some or all of the related entities were previously loaded. JALIYA'S BLOG: USING AN ICOMMAND FOR LISTVIEW ITEM CLICK When we are using MVVM, events triggered from the View should be bound to a ICommand in the ViewModel. In this post let’s see how we can bind an ItemClick event of a ListView to a implementation of a ICommand in the ViewModel. JALIYA'S BLOG: DURABLE FUNCTIONS IN AZURE FUNCTIONS FOR There are a couple of interesting things happening here. Imagine GetSum takes 10 seconds to complete. So that means Function1 will be running for more than 30 seconds. But it’s not. After calling GetSum, Function1 goes to sleep. And when GetSum returns completing his functionality, he notifies Function1 with the return values and Function1 resumes its operation. JALIYA'S BLOG: GETTING THE CURRENT USER'S SHAREPOINT GROUP Hi, Thanks for reply.checked the dataconnection it isperfect.bt it not retrieved the data.the same thing happenedin other forms also.i used some other forms and workflows.in some forms the dataconnection retrieved the value from sharepoint library.in some forms it hs notretrieved.idnt knw why it is notworked in some forms.Pls help me in this regard.i folow the same procd in allforms. JALIYA'S BLOG: C# 8.0: NOTNULL GENERIC CONSTRAINT A couple of months back I wrote a post about C# 8.0: Nullable Reference Types which is a feature coming with C# 8.0. A few days back Microsoft has released .NET Core 3.0 Preview 8. And from .NET Core 3.0 Preview 7 onwards, C# 8.0 is now considered feature complete. JALIYA'S BLOG: SQL SERVER REPORTING SERVICES (SSRS I had a requirement where I wanted to pass multi-valued parameters in a report querying a DB2 database. Couldn't do it myself and posted a question in SQL Server Reporting Services, Power View forum. This nice guy, Charlie Liao came in and solved my JALIYA'S BLOG: WPF: EXTERNAL LOGIN WITH IDENTITY SERVER .NET, .NET Core, ASP.NET, ASP.NET Core, Visual Studio, Jaliya

Udagedara

JALIYA'S BLOG: APRIL 2021 The general recommendation is Processors should be the go-to tool for writing applications that receive messages from Service Bus entities.The Receivers are recommended for more complex scenarios in which the processor is not able to provide the fine-grained control that one can expect when using the Receiver directly. Azure Functions use Processors, so obviously, that's my go-to option. JALIYA'S BLOG: AZURE SERVICE BUS: HANDLING FIFO USING SESSIONS In this post, let's see what Sessions are in Azure Service Bus. The primary use of Sessions (Groups) is to maintain FIFO when there are multiple receivers listening to the same Queue or Subscription. For the simplicity of the post, I will be focusing on Queues rather than Topics/Subscriptions, but the concept is the same. AZURE SERVICE BUS CLIENT LIBRARY FOR .NET: RECEIVERS VS The general recommendation is Processors should be the go-to tool for writing applications that receive messages from Service Bus entities.The Receivers are recommended for more complex scenarios in which the processor is not able to provide the fine-grained control that one can expect when using the Receiver directly. Azure Functions use Processors, so obviously, that's my go-to option. JALIYA'S BLOG: AZURE FUNCTIONS: CONSUMING CONFIGURATION So consider I have an Azure Function App with DI setup. Like 10 days back, Microsoft.Azure.Functions.Extensions version: 1.1.0 was released and with that, one of the new features that got available is Configuration source customization.Basically, that is, in the Startup class, now you can override the ConfigureAppConfiguration. JALIYA'S BLOG: RETRYOPTIONS IN AZURE DURABLE FUNCTIONS The first retry will be in 10 seconds, the second retry will be in 20 seconds (after the first retry fail) and the final retry will be in 30 seconds (after the second retry fail). These are the different options available in RetryOptions that you can use to get the best retry experience. BackoffCoefficient: Gets or sets the backoff coefficient. JALIYA'S BLOG: AZURE DURABLE FUNCTIONS AND EXTERNAL EVENTS Same as in the above step, we will have to either keep polling for status or the the external system will notify us when it's completed, so we can get a handle of the document generated. Now let's see how we can implement this using Azure Durable Functions and External Events. First I have below StarterFunction, which is basically the entry

point.

JALIYA'S BLOG: EF CORE 5.0: MANY TO MANY RELATIONSHIPS EF Core 5.0: Many to Many Relationships. One of the nicest features available in EF Core 5.0 is now you can define a many-to-many relationship without explicitly mapping the join table. With earlier EF Core versions, you didn't have the luxury of doing something like this, You needed to explicitly create the join table, something like

below.

JALIYA'S BLOG: EF CORE: OWNED ENTITY TYPES EF Core: Owned Entity Types. In this post let's see what is Owned Entity Types in Entity Framework Core. This is a very nice feature when it comes to DDD. Owned Entities are entities that can be only appeared on navigation properties of other entity types. Basically, they can't exist without the Owner . JALIYA'S BLOG: C# 8.0: NOTNULL GENERIC CONSTRAINT A couple of months back I wrote a post about C# 8.0: Nullable Reference Types which is a feature coming with C# 8.0. A few days back Microsoft has released .NET Core 3.0 Preview 8. And from .NET Core 3.0 Preview 7 onwards, C# 8.0 is now considered feature complete. JALIYA'S BLOG: APRIL 2021 The general recommendation is Processors should be the go-to tool for writing applications that receive messages from Service Bus entities.The Receivers are recommended for more complex scenarios in which the processor is not able to provide the fine-grained control that one can expect when using the Receiver directly. Azure Functions use Processors, so obviously, that's my go-to option. JALIYA'S BLOG: AZURE SERVICE BUS: HANDLING FIFO USING SESSIONS In this post, let's see what Sessions are in Azure Service Bus. The primary use of Sessions (Groups) is to maintain FIFO when there are multiple receivers listening to the same Queue or Subscription. For the simplicity of the post, I will be focusing on Queues rather than Topics/Subscriptions, but the concept is the same. JALIYA'S BLOG: WPF: EXTERNAL LOGIN WITH IDENTITY SERVER .NET, .NET Core, ASP.NET, ASP.NET Core, Visual Studio, Jaliya

Udagedara

AZURE SERVICE BUS CLIENT LIBRARY FOR .NET: RECEIVERS VS The general recommendation is Processors should be the go-to tool for writing applications that receive messages from Service Bus entities.The Receivers are recommended for more complex scenarios in which the processor is not able to provide the fine-grained control that one can expect when using the Receiver directly. Azure Functions use Processors, so obviously, that's my go-to option. JALIYA'S BLOG: RETRYOPTIONS IN AZURE DURABLE FUNCTIONS The first retry will be in 10 seconds, the second retry will be in 20 seconds (after the first retry fail) and the final retry will be in 30 seconds (after the second retry fail). These are the different options available in RetryOptions that you can use to get the best retry experience. BackoffCoefficient: Gets or sets the backoff coefficient. JALIYA'S BLOG: AZURE DURABLE FUNCTIONS AND EXTERNAL EVENTS Same as in the above step, we will have to either keep polling for status or the the external system will notify us when it's completed, so we can get a handle of the document generated. Now let's see how we can implement this using Azure Durable Functions and External Events. First I have below StarterFunction, which is basically the entry

point.

JALIYA'S BLOG: EF CORE 5.0: MANY TO MANY RELATIONSHIPS EF Core 5.0: Many to Many Relationships. One of the nicest features available in EF Core 5.0 is now you can define a many-to-many relationship without explicitly mapping the join table. With earlier EF Core versions, you didn't have the luxury of doing something like this, You needed to explicitly create the join table, something like

below.

JALIYA'S BLOG: EF CORE: OWNED ENTITY TYPES EF Core: Owned Entity Types. In this post let's see what is Owned Entity Types in Entity Framework Core. This is a very nice feature when it comes to DDD. Owned Entities are entities that can be only appeared on navigation properties of other entity types. Basically, they can't exist without the Owner . JALIYA'S BLOG: AZURE PIPELINES: CREATE/UPDATE AZURE API Once this extension is installed, you should be able to see a bunch of tasks starting with API Management - *. From there what we need is API Management - Create or Update API task. We just need to add this task after the deployment of the API. API Management - Create or Update API. Then it's just a matter of configuring the task. JALIYA'S BLOG: C# 8.0: NOTNULL GENERIC CONSTRAINT A couple of months back I wrote a post about C# 8.0: Nullable Reference Types which is a feature coming with C# 8.0. A few days back Microsoft has released .NET Core 3.0 Preview 8. And from .NET Core 3.0 Preview 7 onwards, C# 8.0 is now considered feature complete. JALIYA'S BLOG: AZURE FUNCTIONS: CONSUMING CONFIGURATION So consider I have an Azure Function App with DI setup. Like 10 days back, Microsoft.Azure.Functions.Extensions version: 1.1.0 was released and with that, one of the new features that got available is Configuration source customization.Basically, that is, in the Startup class, now you can override the ConfigureAppConfiguration. JALIYA'S BLOG: MARCH 2021 In this post, let's see how we can programmatically add Operations to Swagger document in an ASP.NET Core Application. I had a requirement where an Angular application uses DevExpress Report Viewer and the reports are being rendered through an ASP.NET Core API. JALIYA'S BLOG: .NET 6 PREVIEW 4: INTRODUCING MINIMAL APIS In this post, let's see one of the nicest features coming in with ASP.NET Core in .NET 6.This feature is called Minimal APIs, the basic idea is being able to create a REST API with minimal code. JALIYA'S BLOG: AZURE PIPELINES: PASSING VARIABLES BETWEEN Here, I have 2 Stages, Build and Deployment. Build stage has 2 jobs, ; In the FirstJob, I am creating a variable called myVariable.I am making it an output variable and setting its value to Hello World.; In the SecondJob, ; The SecondJob is depending on FirstJob because the variable needs to be created first.; Then I am declaring a variable called myJobVariable and mapping it with myVariable JALIYA'S BLOG: EF CORE: OWNED ENTITY TYPES EF Core: Owned Entity Types. In this post let's see what is Owned Entity Types in Entity Framework Core. This is a very nice feature when it comes to DDD. Owned Entities are entities that can be only appeared on navigation properties of other entity types. Basically, they can't exist without the Owner . JALIYA'S BLOG: AZURE PIPELINES: CREATE/UPDATE AZURE API Once this extension is installed, you should be able to see a bunch of tasks starting with API Management - *. From there what we need is API Management - Create or Update API task. We just need to add this task after the deployment of the API. API Management - Create or Update API. Then it's just a matter of configuring the task. JALIYA'S BLOG: USING OBJECTSTATEMANAGER FOR OBJECT ObjectStateManager in Entity Framework is responsible for tracking states and changes of an object. In this post let’s see how we can use ObjectStateManager to track object changes in following scenarios. Let’s jump into action by creating a console application and installing Entity Framework nuget package (I am installing installing

the

JALIYA'S BLOG: GETTING THE CURRENT USER'S SHAREPOINT GROUP Since this is going to to be a longer post, I think it's better to go as a step by step approach, so I will start from Step 01. Step 01. Select the Custom List and on Ribbon under List click Customize Form. Then the List will be opening in the Microsoft InfoPath Designer 2010

. Step 02.

JALIYA'S BLOG: USING WEBFORMS REPORTVIEWER CONTROL INSIDE Jaliya's Blog: Using WebForms ReportViewer Control Inside AngularJS Single Page Application. WebForms ReportViewer control can be used to render reports deployed to SQL Server Reporting Servcies (SSRS) Report Server or reports which exists in local machine inside a web application. In this post, let’s see how we can use the WebForms JALIYA'S BLOG: SQL SERVER REPORTING SERVICES (SSRS I had a requirement where I wanted to pass multi-valued parameters in a report querying a DB2 database. Couldn't do it myself and posted a question in SQL Server Reporting Services, Power View forum. This nice guy, Charlie Liao came in and solved my JALIYA'S BLOG: APRIL 2021 The general recommendation is Processors should be the go-to tool for writing applications that receive messages from Service Bus entities.The Receivers are recommended for more complex scenarios in which the processor is not able to provide the fine-grained control that one can expect when using the Receiver directly. Azure Functions use Processors, so obviously, that's my go-to option. JALIYA'S BLOG: AZURE SERVICE BUS: HANDLING FIFO USING SESSIONS In this post, let's see what Sessions are in Azure Service Bus. The primary use of Sessions (Groups) is to maintain FIFO when there are multiple receivers listening to JALIYA'S BLOG: WPF: EXTERNAL LOGIN WITH IDENTITY SERVER .NET, .NET Core, ASP.NET, ASP.NET Core, Visual Studio, Jaliya

Udagedara

JALIYA'S BLOG: RETRYOPTIONS IN AZURE DURABLE FUNCTIONS So here, if MyActvity throws an exception of type MyException, we will be retrying again in 10 seconds and maxNumberOfAttempts will be 3.One of the important things to note for the Handle delegate is, you need access exceptions' InnerException if you want to get the actual

exception.

JALIYA'S BLOG: EF CORE 5.0: MANY TO MANY RELATIONSHIPS One of the nicest features available in EF Core 5.0 is now you can define a many-to-many relationship without explicitly mapping the join

table.

JALIYA'S BLOG: AZURE DURABLE FUNCTIONS AND EXTERNAL EVENTS In this post, let's see how we can make use of Azure Durable Functions with its External Event listening feature. This post assumes you have a basic understanding Durable Functions.. Let's consider the following

scenario.

AZURE SERVICE BUS CLIENT LIBRARY FOR .NET: RECEIVERS VS The general recommendation is Processors should be the go-to tool for writing applications that receive messages from Service Bus entities.The Receivers are recommended for more complex scenarios in which the processor is not able to provide the fine-grained control that one can expect when using the Receiver directly. Azure Functions use Processors, so obviously, that's my go-to option. JALIYA'S BLOG: AZURE PIPELINES: CREATE/UPDATE AZURE API Products; Since I have already created a product in the APIM, I can just enter the name of the Product. If you are creating the Product as part of the pipeline (using API Management - Create or update product task), then you need to select Product created by previous task. OpenAPI Specification JALIYA'S BLOG: EF CORE: OWNED ENTITY TYPES Note: I am using anotherContext here for retrieval, because EF Core will automatically fix-up navigation properties to any other entities that were previously loaded into the context instance. So even if you don't explicitly include the data for a navigation property, the property may still be populated if some or all of the related entities were previously loaded. JALIYA'S BLOG: C# 8.0: NOTNULL GENERIC CONSTRAINT A couple of months back I wrote a post about C# 8.0: Nullable Reference Types which is a feature coming with C# 8.0. A few days back Microsoft has released .NET Core 3.0 Preview 8. And from .NET Core 3.0 Preview 7 onwards, C# 8.0 is now considered feature complete. JALIYA'S BLOG: APRIL 2021 The general recommendation is Processors should be the go-to tool for writing applications that receive messages from Service Bus entities.The Receivers are recommended for more complex scenarios in which the processor is not able to provide the fine-grained control that one can expect when using the Receiver directly. Azure Functions use Processors, so obviously, that's my go-to option. JALIYA'S BLOG: AZURE SERVICE BUS: HANDLING FIFO USING SESSIONS In this post, let's see what Sessions are in Azure Service Bus. The primary use of Sessions (Groups) is to maintain FIFO when there are multiple receivers listening to JALIYA'S BLOG: WPF: EXTERNAL LOGIN WITH IDENTITY SERVER .NET, .NET Core, ASP.NET, ASP.NET Core, Visual Studio, Jaliya

Udagedara

JALIYA'S BLOG: RETRYOPTIONS IN AZURE DURABLE FUNCTIONS So here, if MyActvity throws an exception of type MyException, we will be retrying again in 10 seconds and maxNumberOfAttempts will be 3.One of the important things to note for the Handle delegate is, you need access exceptions' InnerException if you want to get the actual

exception.

JALIYA'S BLOG: EF CORE 5.0: MANY TO MANY RELATIONSHIPS One of the nicest features available in EF Core 5.0 is now you can define a many-to-many relationship without explicitly mapping the join

table.

JALIYA'S BLOG: AZURE DURABLE FUNCTIONS AND EXTERNAL EVENTS In this post, let's see how we can make use of Azure Durable Functions with its External Event listening feature. This post assumes you have a basic understanding Durable Functions.. Let's consider the following

scenario.

AZURE SERVICE BUS CLIENT LIBRARY FOR .NET: RECEIVERS VS The general recommendation is Processors should be the go-to tool for writing applications that receive messages from Service Bus entities.The Receivers are recommended for more complex scenarios in which the processor is not able to provide the fine-grained control that one can expect when using the Receiver directly. Azure Functions use Processors, so obviously, that's my go-to option. JALIYA'S BLOG: AZURE PIPELINES: CREATE/UPDATE AZURE API Products; Since I have already created a product in the APIM, I can just enter the name of the Product. If you are creating the Product as part of the pipeline (using API Management - Create or update product task), then you need to select Product created by previous task. OpenAPI Specification JALIYA'S BLOG: EF CORE: OWNED ENTITY TYPES Note: I am using anotherContext here for retrieval, because EF Core will automatically fix-up navigation properties to any other entities that were previously loaded into the context instance. So even if you don't explicitly include the data for a navigation property, the property may still be populated if some or all of the related entities were previously loaded. JALIYA'S BLOG: C# 8.0: NOTNULL GENERIC CONSTRAINT A couple of months back I wrote a post about C# 8.0: Nullable Reference Types which is a feature coming with C# 8.0. A few days back Microsoft has released .NET Core 3.0 Preview 8. And from .NET Core 3.0 Preview 7 onwards, C# 8.0 is now considered feature complete. JALIYA'S BLOG: EF CORE: OWNED ENTITY TYPES Note: I am using anotherContext here for retrieval, because EF Core will automatically fix-up navigation properties to any other entities that were previously loaded into the context instance. So even if you don't explicitly include the data for a navigation property, the property may still be populated if some or all of the related entities were previously loaded. JALIYA'S BLOG: EF CORE 5.0: SAVECHANGES EVENTS AND Here note that the event sender is always the DbContext instance.. Interceptors. Interceptors can be used for interception (as the name suggests of course), modification, and most importantly Interceptors allow SaveChanges to be suppressed unlike Events. JALIYA'S BLOG: USING OBJECTSTATEMANAGER FOR OBJECT Let’s jump into action by creating a console application and installing Entity Framework nuget package (I am installing installing the latest as of today which is 6.1.2) the project.In this application, I am going create a code-first sample database with three POCO entity types which are “Department”, “Hobby” and “Person”.I am modeling the entities and their relationships as

follows.

JALIYA'S BLOG: AZURE PIPELINES: PASSING VARIABLES BETWEEN Here, I have 2 Stages, Build and Deployment. Build stage has 2 jobs, ; In the FirstJob, I am creating a variable called myVariable.I am making it an output variable and setting its value to Hello World.; In the SecondJob, ; The SecondJob is depending on FirstJob because the variable needs to be created first.; Then I am declaring a variable called myJobVariable and mapping it with myVariable JALIYA'S BLOG: AZURE FUNCTIONS: CHANGE PLANTYPE FROM This is a quick post on how we can change the Plan Type of an Azure Function App from Consumption (Serverless) to a Premium Plan. If you have created an Azure Function App initially selecting Consumption (Serverless) as the plan type and then later if you want to change it to a Premium Plan, Azure Portal has no direct way to do it. Here you

have 2 options,

JALIYA'S BLOG: .NET CORE: TIERED COMPILATION A couple of days back during the .NET Conf, there were some major announcements along with the release of .NET Core 3.0.In this post, I am going to write about something which has been there for almost a year, wasn't available by default, but with .NET Core 3.0, it will be enabled by default.This feature is called Tiered Compilation. Before moving into Tiered Compilation, let's have a quick JALIYA'S BLOG: DOCKER DESKTOP FOR WINDOWS: KUBERNETES Some have suggested doing a complete Docker Desktop cleanup and reinstall, but I didn't want to do that. After spending a couple of hours, found the logs at this directory: C:\ProgramData\DockerDesktop.There were some service.txt files, and I have opened the recently modified one and finally able to found out

what the issue is.

JALIYA'S BLOG: SQL SERVER REPORTING SERVICES (SSRS I had a requirement where I wanted to pass multi-valued parameters in a report querying a DB2 database. Couldn't do it myself and posted a question in SQL Server Reporting Services, Power View forum. This nice guy, Charlie Liao came in and solved my JALIYA'S BLOG: GETTING THE CURRENT USER'S SHAREPOINT GROUP Hi, Thanks for reply.checked the dataconnection it isperfect.bt it not retrieved the data.the same thing happenedin other forms also.i used some other forms and workflows.in some forms the dataconnection retrieved the value from sharepoint library.in some forms it hs notretrieved.idnt knw why it is notworked in some forms.Pls help me in this regard.i folow the same procd in allforms. JALIYA'S BLOG: ASP.NET GRIDVIEW ROW EDIT MODE It's great to have CRUD operations in a single place and ASP.NET GridView provides this feature in a nice way. Without much pre writing I will just start off with the topic. JALIYA'S BLOG: APRIL 2021 In this post, let's see what Sessions are in Azure Service Bus. The primary use of Sessions (Groups) is to maintain FIFO when there are multiple receivers listening to the same Queue or Subscription. For the simplicity of the post, I will be focusing on Queues rather than Topics/Subscriptions, but the concept is the same. JALIYA'S BLOG: AZURE SERVICE BUS: HANDLING FIFO USING SESSIONS In this post, let's see what Sessions are in Azure Service Bus. The primary use of Sessions (Groups) is to maintain FIFO when there are multiple receivers listening to the same Queue or Subscription. For the simplicity of the post, I will be focusing on Queues rather than Topics/Subscriptions, but the concept is the same. AZURE SERVICE BUS CLIENT LIBRARY FOR .NET: RECEIVERS VS The general recommendation is Processors should be the go-to tool for writing applications that receive messages from Service Bus entities.The Receivers are recommended for more complex scenarios in which the processor is not able to provide the fine-grained control that one can expect when using the Receiver directly. Azure Functions use Processors, so obviously, that's my go-to option. JALIYA'S BLOG: USING OBJECTSTATEMANAGER FOR OBJECT ObjectStateManager in Entity Framework is responsible for tracking states and changes of an object. In this post let’s see how we can use ObjectStateManager to track object changes in following scenarios. Let’s jump into action by creating a console application and installing Entity Framework nuget package (I am installing installing

the

JALIYA'S BLOG: RETRYOPTIONS IN AZURE DURABLE FUNCTIONS The first retry will be in 10 seconds, the second retry will be in 20 seconds (after the first retry fail) and the final retry will be in 30 seconds (after the second retry fail). These are the different options available in RetryOptions that you can use to get the best retry experience. BackoffCoefficient: Gets or sets the backoff coefficient. JALIYA'S BLOG: WPF: EXTERNAL LOGIN WITH IDENTITY SERVER .NET, .NET Core, ASP.NET, ASP.NET Core, Visual Studio, Jaliya

Udagedara

JALIYA'S BLOG: .NET CORE: TIERED COMPILATION A couple of days back during the .NET Conf, there were some major announcements along with the release of .NET Core 3.0.In this post, I am going to write about something which has been there for almost a year, wasn't available by default, but with .NET Core 3.0, it will be enabled by default.This feature is called Tiered Compilation. Before moving into Tiered Compilation, let's have a quick JALIYA'S BLOG: USING AN ICOMMAND FOR LISTVIEW ITEM CLICKUWP LISTVIEWUWP LISTVIEW The easy way to do this by using Blend. Right click on the MainPage.xaml and click on “Open in Blend”. Opened in Blend. First open up the Objects and Timeline window, and drill up to ListView. Select the ListView and from the Assets window, select Behaviors and double click on EventTriggerBehavior. JALIYA'S BLOG: GETTING THE CURRENT USER'S SHAREPOINT GROUP Since this is going to to be a longer post, I think it's better to go as a step by step approach, so I will start from Step 01. Step 01. Select the Custom List and on Ribbon under List click Customize Form. Then the List will be opening in the Microsoft InfoPath Designer 2010

. Step 02.

JALIYA'S BLOG: PASSING NULLABLE VALUE FOR A DBCOMMAND Passing Nullable Value for a DbCommand Parameter. I had this requirement where I wanted to pass a nullable property for a Parameter in DbCommand. public void Execute (int? someId) { using (DbCommand dbCommand = _context.Database.GetDbConnection ().CreateCommand ()) { dbCommand.CommandType = CommandType.StoredProcedure; dbCommand.CommandText JALIYA'S BLOG: APRIL 2021 In this post, let's see what Sessions are in Azure Service Bus. The primary use of Sessions (Groups) is to maintain FIFO when there are multiple receivers listening to the same Queue or Subscription. For the simplicity of the post, I will be focusing on Queues rather than Topics/Subscriptions, but the concept is the same. JALIYA'S BLOG: AZURE SERVICE BUS: HANDLING FIFO USING SESSIONS In this post, let's see what Sessions are in Azure Service Bus. The primary use of Sessions (Groups) is to maintain FIFO when there are multiple receivers listening to the same Queue or Subscription. For the simplicity of the post, I will be focusing on Queues rather than Topics/Subscriptions, but the concept is the same. AZURE SERVICE BUS CLIENT LIBRARY FOR .NET: RECEIVERS VS The general recommendation is Processors should be the go-to tool for writing applications that receive messages from Service Bus entities.The Receivers are recommended for more complex scenarios in which the processor is not able to provide the fine-grained control that one can expect when using the Receiver directly. Azure Functions use Processors, so obviously, that's my go-to option. JALIYA'S BLOG: USING OBJECTSTATEMANAGER FOR OBJECT ObjectStateManager in Entity Framework is responsible for tracking states and changes of an object. In this post let’s see how we can use ObjectStateManager to track object changes in following scenarios. Let’s jump into action by creating a console application and installing Entity Framework nuget package (I am installing installing

the

JALIYA'S BLOG: RETRYOPTIONS IN AZURE DURABLE FUNCTIONS The first retry will be in 10 seconds, the second retry will be in 20 seconds (after the first retry fail) and the final retry will be in 30 seconds (after the second retry fail). These are the different options available in RetryOptions that you can use to get the best retry experience. BackoffCoefficient: Gets or sets the backoff coefficient. JALIYA'S BLOG: WPF: EXTERNAL LOGIN WITH IDENTITY SERVER .NET, .NET Core, ASP.NET, ASP.NET Core, Visual Studio, Jaliya

Udagedara

JALIYA'S BLOG: .NET CORE: TIERED COMPILATION A couple of days back during the .NET Conf, there were some major announcements along with the release of .NET Core 3.0.In this post, I am going to write about something which has been there for almost a year, wasn't available by default, but with .NET Core 3.0, it will be enabled by default.This feature is called Tiered Compilation. Before moving into Tiered Compilation, let's have a quick JALIYA'S BLOG: USING AN ICOMMAND FOR LISTVIEW ITEM CLICKUWP LISTVIEWUWP LISTVIEW The easy way to do this by using Blend. Right click on the MainPage.xaml and click on “Open in Blend”. Opened in Blend. First open up the Objects and Timeline window, and drill up to ListView. Select the ListView and from the Assets window, select Behaviors and double click on EventTriggerBehavior. JALIYA'S BLOG: GETTING THE CURRENT USER'S SHAREPOINT GROUP Since this is going to to be a longer post, I think it's better to go as a step by step approach, so I will start from Step 01. Step 01. Select the Custom List and on Ribbon under List click Customize Form. Then the List will be opening in the Microsoft InfoPath Designer 2010

. Step 02.

JALIYA'S BLOG: PASSING NULLABLE VALUE FOR A DBCOMMAND Passing Nullable Value for a DbCommand Parameter. I had this requirement where I wanted to pass a nullable property for a Parameter in DbCommand. public void Execute (int? someId) { using (DbCommand dbCommand = _context.Database.GetDbConnection ().CreateCommand ()) { dbCommand.CommandType = CommandType.StoredProcedure; dbCommand.CommandText JALIYA'S BLOG: .NET 6 PREVIEW 4: INTRODUCING MINIMAL APIS In this post, let's see one of the nicest features coming in with ASP.NET Core in .NET 6.This feature is called Minimal APIs, the basic idea is being able to create a REST API with minimal code. JALIYA'S BLOG: AZURE SERVICE BUS: HANDLING FIFO USING SESSIONS In this post, let's see what Sessions are in Azure Service Bus. The primary use of Sessions (Groups) is to maintain FIFO when there are multiple receivers listening to the same Queue or Subscription. For the simplicity of the post, I will be focusing on Queues rather than Topics/Subscriptions, but the concept is the same. JALIYA'S BLOG: WPF: EXTERNAL LOGIN WITH IDENTITY SERVER WPF: External Login with Identity Server using Microsoft Edge WebView2 JALIYA'S BLOG: AZURE DURABLE FUNCTIONS AND EXTERNAL EVENTS Same as in the above step, we will have to either keep polling for status or the the external system will notify us when it's completed, so we can get a handle of the document generated. Now let's see how we can implement this using Azure Durable Functions and External Events. First I have below StarterFunction, which is basically the entry

point.

JALIYA'S BLOG: EF CORE: USING HILO ALGORITHM TO GENERATE IDS This will return 1, and the category will be assigned the value of 1 and it has now blocked Ids from 1 to 10. If we add in another category in the same database context, EF won't run the above query again, it will increment the Id by 1 and when we have added 10 categories, EF will run the above query again to get the next value, which will be

11.

JALIYA'S BLOG: CALLING WCF SERVICE FROM A STORED PROCEDURE So what we can do is write a Stored Procedure with the use of SQL CLR which will call and consume from the WCF Service. Then we can write a T-SQL Stored Procedure to call the SQL CLR Stored Procedure. Different SQL Server versions uses different CLR versions. SQL Server 2012 uses version 4.0 of the CLR although previous versions of SQL Server JALIYA'S BLOG: ASP.NET GRIDVIEW ROW EDIT MODE The editable fields of the row will change into edit mode and the "Edit" button will disappear. Instead of "Edit" button, three more buttons will come to the picture which will be "Update","Delete" and "Cancel". I hope you all got the target well, let's start achieving it. So basically we will have two modes and some custom controls. JALIYA'S BLOG: SQL SERVER REPORTING SERVICES (SSRS I had a requirement where I wanted to pass multi-valued parameters in a report querying a DB2 database. Couldn't do it myself and posted a question in SQL Server Reporting Services, Power View forum. This nice guy, Charlie Liao came in and solved my JALIYA'S BLOG: C# 8.0: NULLABLE REFERENCE TYPES So starting with C# 8.0, all the reference type variables are not nullable and if the compiler sees a code trying to dereference a non-nullable reference type, it will issue a warning. But as of now, you are opted-out for this feature by default. You can opt-in to this feature (which is known as nullable contexts) using the following two

JALIYA'S BLOG: 2013

Getting Caller Information using Caller Info attributes is initially introduced with .NET Framework 4.5. It can be real handy if you want to write a module for tracing, debugging etc.

JALIYA'S BLOG

PAGES

* Home

* Sessions

* TNWiki

* Featured

* Contact

MONDAY, OCTOBER 7, 2019 .NET CORE: TIERED COMPILATION A couple of days back during the .NET Conf, there were some major announcements along with the release of .NET Core 3.0

.

In this post, I am going to write about something which has been there for almost a year, wasn't available by default, but with .NET Core

3.0

,

it will be enabled by default. This feature is called TIERED

COMPILATION.

Before moving into TIERED COMPILATION, let's have a quick recap of how .NET Compilation works. First, the code we have written using high-level languages (C#, F#, etc.) will be compiled into an exe or dll which contains CIL (Common Intermediate Language). And during the run-time, the methods are compiled into Native/Machine code. This is being carried out by JIT (Just-In-Time Compiler) and the process is known as _jitting_. Basically, whenever some method is being called, that method gets jitted and being stored. When this method is called next time, the method won't get jitted again, instead, it will be loaded from the memory. So all the methods in our code were compiled

ONLY ONCE.

Let's just go by an example. Imagine you have this MethodA(), which will get called when you are starting your application. And it will get called throughout the life cycle of your application. JIT can do a very good optimization for your MethodA() based on a variety of algorithms. But that would make your application start slowly. On the other hand, JIT can use a simple algorithm and jit the method fast, so your application would start faster, but the generated code might not be properly optimized and the MethodA() will perform slow. Enter TIERED COMPILATION. With Tiered Compilation, based on the usage of a method, it can get jitted more than once and can be hot-swapped at runtime. So basically JIT can pick an approach to start the application fast, and then based on the usage of a method and if the method appears hot, it will compile the same method again to generate more efficient code and use it for future calls. This is how the Tiered Compilation works. First Tiered Compilation breaks the code into 2 buckets. * Code that is eligible for tiering

* Tier0

* This is usually the less optimized code that is generated using minimal optimizations. That is when the method is first invoked, the Tier0 version generated.

* Tier1

* This is whatever code the runtime thinks will run faster than Tier0. If any method appears hot, the runtime would jit the method again with a more optimized version and will replace Tier0. * Code that is NOT eligible for tiering * Will be jitted as before Tiered Compilation was introduced Tiered Compilation was added as an opt-in feature in .NET Core 2.1. But with .NET Core 3.0,  it is enabled by default. To enable Quick JIT (Tier0 jitted code), update the .csproj as

follows.

true

To disable Tiered compilation,  update the .csproj as follows. false

More information:

Tiered Compilation

Tiered Compilation Guide

Happy Coding.

Regards,

Jaliya

Posted by Jaliya Udagedara at 12:29 PM

0 comments

Email This

BlogThis!

Share

to Twitter

Share

to Facebook

Share

to Pinterest

Reactions:

MONDAY, SEPTEMBER 30, 2019 VISUAL C# TECHNICAL GURU - AUGUST 2019 Another month as a judge in Microsoft TechNet Guru Awards under Visual C# category. The TechNet Guru Awards celebrate the technical articles on Microsoft TechNet. Post in Official Blog, https://techcommunity.microsoft.com/t5/Azure-Developer-Community-Blog/TechNet-Guru-Winners-August-2019/ba-p/884535 Visual C# Technical Guru - August 2019

Happy Coding.

Regards,

Jaliya

Posted by Jaliya Udagedara at 10:29 PM

0 comments

Email This

BlogThis!

Share

to Twitter

Share

to Facebook

Share

to Pinterest

Reactions:

MONDAY, SEPTEMBER 9, 2019 INTRODUCING VISUAL STUDIO TERMINAL With the release of VISUAL STUDIO 2019 VERSION 16.3 PREVIEW 3, an early preview of VISUAL STUDIO TERMINAL was released. While it's still in its early stages, you can still experience how it looks like. Even if you have already installed VISUAL STUDIO 2019 VERSION 16.3 PREVIEW 3, the feature is disabled by default. But you can enable it pretty easily bygoing to TOOLS -> OPTIONS. And then under ENVIRONMENT node, find the PREVIEW FEATURES. From there just tick EXPERIMENTAL VS TERMINAL and restart VS.

Preview Features

Once restarted, you can find the TERMINAL  WINDOW option under VIEWS toolbar menu item. Or as always, you can use the Search bar. Visual Studio Terminal The font in the terminal looks smaller to me, but hopefully, we will get some options to customize the terminal in the future. But for now, this is more than enough for me.

Do try this out!

Happy Coding.

Regards,

Jaliya

Posted by Jaliya Udagedara at 2:10 PM

0 comments

Email This

BlogThis!

Share

to Twitter

Share

to Facebook

Share

to Pinterest

Reactions:

SATURDAY, AUGUST 31, 2019 VISUAL C# TECHNICAL GURU - JULY 2019 Another month as a judge in Microsoft TechNet Guru Awards under Visual C# category. The TechNet Guru Awards celebrate the technical articles on Microsoft TechNet. Post in Official Blog, https://techcommunity.microsoft.com/t5/Azure-Developer-Community-Blog/TechNet-Guru-Winners-July-2019/ba-p/832644 Visual C# Technical Guru - July 2019

Happy Coding.

Regards,

Jaliya

Posted by Jaliya Udagedara at 11:14 PM

0 comments

Email This

BlogThis!

Share

to Twitter

Share

to Facebook

Share

to Pinterest

Reactions:

WEDNESDAY, AUGUST 21, 2019 C# 8.0: NOTNULL GENERIC CONSTRAINT A couple of months back I wrote a post about C# 8.0: Nullable

Reference Types

which

is a feature coming with C# 8.0. A few days back Microsoft has released .NET Core 3.0 Preview 8. And from .NET Core 3.0 Preview 7 onwards, C# 8.0 is now considered FEATURE COMPLETE. In this post, let's go through this nice feature added regarding Nullable Reference Types which is NOTNULL generic constraint. This feature was released with .NET Core 3.0 Preview 7. NULLABLE REFERENCE TYPES is an opt-in feature, meaning it's not enabled by default. In this post, I am not going to explain how you can enable it, you can refer to the old post linked above for that. Consider the following code. I have a generic interface, a class that implements it. Even though I have added the interface and the class in the same file, consider this an external library. Now from the Main, I am creating an object of MyClass of type nullable string and calling its method. Note: I have enabled Nullable Reference Types.

#nullable enable

namespace ConsoleApp1

{

interface IMyInterface

{

void MyMethod(TIn input);

}

public class MyClass : IMyInterface

{

public void MyMethod(TIn input)

{

// some code which uses input

}

}

class Program

{

static void Main(string args)

{

string? myString = null; var myClass = new MyClass(); myClass.MyMethod(myString);

}

}

}

The above code will not show any warnings. Now imagine for some reason, I don't want to allow the generic type to be nullable. Enter NOTNULL Generic Constraint. I can update the code as follows. interface IMyInterface where TIn : notnull

{

void MyMethod(TIn input);

}

public class MyClass : IMyInterface where TIn : notnull

{

public void MyMethod(TIn input)

{

// some code which uses input

}

}

We need to add the constraint to both the interface and the class. As soon as we do that, the following line will issue a warning. // Warning CS8714  The type 'string?' cannot be used as type parameter 'TIn' in the generic type or method 'MyClass'. // Nullability of type argument 'string?' doesn't match 'notnull' constraint. var myClass = new MyClass(); We can fix the warning by update the code as follows. var myClass = new MyClass(); And then we will need to fix the next warning of trying to pass a nullable string to MyMethod. I really find this a really handy feature. One of the best examples would be, Microsoft has already constrained DICTIONARY, where TKey is now to be NOTNULL, which disallows using null as a key.

Hope this helps.

Happy Coding.

Regards,

Jaliya

Posted by Jaliya Udagedara at 1:57 PM

0 comments

Email This

BlogThis!

Share

to Twitter

Share

to Facebook

Share

to Pinterest

Reactions:

WEDNESDAY, JULY 31, 2019 ASP.NET TECHNICAL GURU - JUNE 2019 Another month as a judge in Microsoft TechNet Guru Awards under ASP.NET category. The TechNet Guru Awards celebrate the technical articles on Microsoft TechNet.

Original Post,

https://techcommunity.microsoft.com/t5/Azure-Developer-Community-Blog/TechNet-Guru-Winners-June-2019/ba-p/781392 ASP.NET Technical Guru - June 2019

Happy Coding.

Regards,

Jaliya

Posted by Jaliya Udagedara at 11:35 PM

0 comments

Email This

BlogThis!

Share

to Twitter

Share

to Facebook

Share

to Pinterest

Reactions:

TUESDAY, JULY 30, 2019 ASP.NET CORE HOSTING MODELS WITH IIS With the introduction of ASP.NET Core 2.2, ASP.NET team has introduced 2 hosting models when we are hosting the ASP.NET Core

application in IIS.

One is IN-PROCESS and the other is OUT-OF-PROCESS. In-process hosting is made possible with the introduction of ASPNETCOREMODULEV2 which is a required to host ASP.NET Core applications targeting 2.2 or higher. You will get this once you install .NET Core Runtime & Hosting Bundle

which is a

prerequisite.

You can configure the hosting model pretty easily through one of the following approaches. 1. Through Project Properties in Visual Studio, Under Debug

Visual Studio

2. From the csproj file

csproj file

If the property isn't present in the file, the default value is OUTOFPROCESS. By doing this when the project is published, the web.config file will contain information on whether to run the application In-Process or

Out-of-process.

So what’s is IN-PROCESS and OUT-OF-PROCESS hosting.

IN-PROCESS

In process basically means the ASP.NET Core application will get run inside IIS Worker process (w3wp.exe) and hence the naming. So here IS HTTP Server (IISHTTPSERVER) is used instead of Kestrel server.

OUT-OF-PROCESS

When on Out-of-process, ASP.NET Core application does not run on IIS Worker process, instead it will be running on Kestrel and all the requests are being forwarded to Kestrel. So what is preferred and why. In-process is the preferred hosting model in IIS. In-process hosting provides improved performance because requests don’t get proxied over to a separate DOTNET process. Microsoft states there is an improved throughput of up to 400% on when In-process hosting model is IIS.

More Information,

Host ASP.NET Core on Windows with IIS

ASP.NET Core Module

Hope this helps.

Happy Coding.

Regards,

Jaliya

Posted by Jaliya Udagedara at 1:56 PM

0 comments

Email This

BlogThis!

Share

to Twitter

Share

to Facebook

Share

to Pinterest

Reactions:

THURSDAY, JULY 4, 2019 ASP.NET TECHNICAL GURU - MAY 2019 Another month as a judge in Microsoft TechNet Guru Awards under ASP.NET category. The TechNet Guru Awards celebrate the technical articles on Microsoft TechNet.

Original Post,

https://social.technet.microsoft.com/wiki/contents/articles/53084.technet-guru-winners-may-2019.aspx ASP.NET Technical Guru - May 2019

Happy Coding.

Regards,

Jaliya

Posted by Jaliya Udagedara at 11:56 PM

0 comments

Email This

BlogThis!

Share

to Twitter

Share

to Facebook

Share

to Pinterest

Reactions:

MONDAY, JULY 1, 2019 RECEIVED MICROSOFT MVP AWARD IN DEVELOPER TECHNOLOGIES I am honored to receive the precious Microsoft Most Valuable Professional (MVP) Award for the sixth consecutive year. As always looking forward to another great year on top of Microsoft

Development Stack.

Microsoft Most Valuable Professional (MVP) Thank you MICROSOFT for your appreciation and Thank you everyone for your continuous support.

Happy Coding.

Regards,

Jaliya

Posted by Jaliya Udagedara at 11:15 PM

0 comments

Email This

BlogThis!

Share

to Twitter

Share

to Facebook

Share

to Pinterest

Reactions:

SUNDAY, JUNE 30, 2019 TASK.WAIT() VS TASK.GETAWAITER().GETRESULT() In this post, let's go through one of the best practices when using

ASYNC/AWAIT.

In some cases, we might want to run an async method synchronously and wait for the execution to be completed. Let's consider the below code. static void Main(string args)

{

// 1

RunSomeTask().Wait();

// 2

//RunSomeTask().GetAwaiter().GetResult();

}

private static async Task RunSomeTask()

{

// some long running work

}

So our options to call RUNSOMETASK synchronously would be something

like below,

* Task.Wait() (or Task.Result to get the return value if it returns

something)

* Task.GetAwaiter().GetResult() What would you prefer? So the best practice is, we should be using TASK.GETAWAITER().GETRESULT() instead of TASK.WAIT()/TASK.RESULT().

Let's see why.

For the purpose of this post, I am modifying the RUNSOMETASK() method to throw an exception. private static async Task RunSomeTask()

{

await Task.Delay(200); throw new Exception("Failed because of some reason");

}

Now let's have a look at 2 different outputs. WHEN USED TASK.WAIT():

Task.Wait()

WHEN USED TASK.GETAWAITER().GETRESULT(): Task.GetAwaiter().GetResult() As you can see when used TASK.WAIT(), if the task threw an exception, it will be wrapped inside an AGGREGATEEXCEPTION. But when we are using TASK.GETAWAITER().GETRESULT(), it will throw the exception directly which will make things like debugging/logging easy. That's a very simple tip, but can be really useful. On a final note, we should avoid calling tasks synchronously as much

as possible.

Hope this helps.

Happy Coding.

Regards,

Jaliya

Posted by Jaliya Udagedara at 11:39 PM

0 comments

Email This

BlogThis!

Share

to Twitter

Share

to Facebook

Share

to Pinterest

Reactions:

WEDNESDAY, JUNE 19, 2019 BEST OF BUILD VIEWING PARTY - AUCKLAND 2019 Today we had the BUILD VIEWING PARTY in Auckland announcing the best of Microsoft Build 2019.  We had a very good panel discussion talking about a variety of things such as AI, Power BI, Development

Technologies etc.

And I delivered a talk on INTRODUCTION TO .NET 5 which is one of the biggest announcements this year.

Panel Discussion

Happy Coding.

Regards,

Jaliya

Posted by Jaliya Udagedara at 10:07 PM

0 comments

Email This

BlogThis!

Share

to Twitter

Share

to Facebook

Share

to Pinterest

Reactions:

WEDNESDAY, JUNE 5, 2019 VISUAL C# TECHNICAL GURU - APRIL 2019 Another month as a judge in Microsoft TechNet Guru Awards under Visual C# category. The TechNet Guru Awards celebrate the technical articles on Microsoft TechNet. Post in WikiNinjas Official Blog, https://blogs.technet.microsoft.com/wikininjas/2019/06/04/technet-wiki-guru-winners-april-2019/ Visual C# Technical Guru - April 2019

Happy Coding.

Regards,

Jaliya

Posted by Jaliya Udagedara at 1:34 AM

0 comments

Email This

BlogThis!

Share

to Twitter

Share

to Facebook

Share

to Pinterest

Reactions:

TUESDAY, MAY 28, 2019 WROTE A POST ON WIKI LIFE AT OFFICIAL BLOG OF TECHNET WIKI Wrote a post in Wiki Ninjas - Official Blog of TechNet Wiki. The title of the post is TNWIKI ARTICLE SPOTLIGHT - BLAZOR: DEPLOYING AN APPLICATION ON FIREBASE. TNWiki Article Spotlight - Blazor: Deploying An Application On

Firebase

Read the rest on,

TNWiki Article Spotlight - Blazor: Deploying An Application On

Firebase

Happy Coding.

Regards,

Jaliya

Posted by Jaliya Udagedara at 2:18 PM

0 comments

Email This

BlogThis!

Share

to Twitter

Share

to Facebook

Share

to Pinterest

Reactions:

TUESDAY, MAY 7, 2019

INTRODUCING .NET 5

At this year's Microsoft Build conference, one of the biggest announcements for developers is what's going to be the future for .NET. In this post, let's see what that is. Before talking about what's next for .NET, let's have a quick recap of the history of .NET. The first version of .NET is .NET Framework 1.0 which was released back in February 2002. It has come a long way since then, almost for more than 17 years and today, the latest version is .NET Framework 4.8. .NET Framework is only available in Windows

machines.

In November 2014, .NET Core 1.0 was released. The main idea of introducing .NET Core is going cross-platform. .NET Core has evolved rapidly since then, as of today the latest version of .NET Core is .NET Core 2.2. .NET Core 3.0 is scheduled to be released on September 2019, while the preview release, .NET Core 3.0 Preview 5 is already out there. For all this time, Microsoft was porting features of .NET Framework to .NET Core. .NET Core 3.0 embraces the desktop by adding WinForms, WPF and Entity Framework 6 making it possible to port desktop applications to .NET Core. On the other hand, there is Mono framework, which is an open source implementation of Microsoft’s .NET Framework that originally targetted Linux. It is based on the open standards which has its own C# compiler and a Common Language Runtime. Mono 1.0 was released in June 2004 and as of today, the latest Mono release is 5.20. So there are basically 3 implementations of .NET, .NET Framework, .NET Core and Mono. All these frameworks has its own Base Class Libraries.

So what's next.

6th of May, 2019, Microsoft has announced .NET 5, which is the next release after .NET Core 3.0. Microsoft is skipping .NET Core 4.0 version name because it can cause confusion with .NET Framework 4.x versions which have been there for a long time. And with .NET 5, there will be just one .NET going forward, so there is no need for a special term "Core". But of course, you can use the “.NET Core” name if

you like it.

.NET Core 3.0 will be the core for .NET 5 and great features from Mono will be moved in (currently Mono runs on more platforms than .NET Core like Android, iOS, PlayStation etc). .NET Framework 4.8 will be the last major version of .NET Framework. But that doesn't mean it's completely abandoned, it will get service updates and support for years to come. But after .NET Core 3.0, Microsoft will not be porting any more features from .NET Framework. So here is what's going to be new with .NET 5. * You will have two choices on runtime experiences.

* CoreCLR or Mono

* These two runtimes has it's own unique capabilities and you will be able to decide which runtime to use using very simple configuration * Java interoperability will be available on all platforms. * Objective-C and Swift interoperability will be supported on multiple operating systems. * CoreFX will be extended to support static compilation of .NET (AOT), smaller footprints and support for more operating systems.

RELEASE SCHEDULE

.NET 5 is scheduled to be released on November 2020, with the first preview available in the first half of 2020.

.NET Schedule

After November 2020, Microsoft will be shipping a major version of .NET once a year, every November and every even-numbered release will have LTS (Long Term Support).

DEVELOPERS TAKE

* New applications should be built on .NET Core. * If you are a Web Forms developer and want to build a new application on .NET Core, Microsoft recommends Blazor

.

* If you are remoting or WCF Server developer and want to build a new application on .NET Core, Microsoft recommends using either ASP.NET Core Web APIs, gRPC (provides cross-platform and cross programming language contract based RPCs) or Core WCF

.

* If you are a Windows Workflow developer, Microsoft recommends Core

WF .

Exciting times ahead!

Happy Coding.

Regards,

Jaliya

Posted by Jaliya Udagedara at 6:20 PM

0 comments

Email This

BlogThis!

Share

to Twitter

Share

to Facebook

Share

to Pinterest

Reactions:

TUESDAY, APRIL 30, 2019 VISUAL C# TECHNICAL GURU - MARCH 2019 Another month as a judge in Microsoft TechNet Guru Awards under Visual C# category. The TechNet Guru Awards celebrate the technical articles on Microsoft TechNet. Post in WikiNinjas Official Blog, https://blogs.technet.microsoft.com/wikininjas/2019/04/30/its-the-technet-guru-winner-awards-march-2019/ Visual C# Technical Guru - March 2019

Happy Coding.

Regards,

Jaliya

Posted by Jaliya Udagedara at 11:17 PM

0 comments

Email This

BlogThis!

Share

to Twitter

Share

to Facebook

Share

to Pinterest

Reactions:

SATURDAY, APRIL 27, 2019 GLOBAL AZURE BOOTCAMP 2019 - AUCKLAND, NEW ZEALAND I was fortunate enough to support Global Azure Bootcamp 2019 - Auckland, New Zealand

.

Global Azure Bootcamp is a worldwide event happening on every year, and this time the day was April 27, 2019. The entire day was filled with great sessions delivered by industry experts from a variety of

areas.

Global Azure Bootcamp 2019 - Auckland, New Zealand - Speakers I couldn't deliver a session but managed to support the event at

least.

Support Team

Happy Coding.

Regards,

Jaliya

Posted by Jaliya Udagedara at 10:37 PM

0 comments

Email This

BlogThis!

Share

to Twitter

Share

to Facebook

Share

to Pinterest

Reactions:

WEDNESDAY, APRIL 3, 2019 LIVE SHARE IN VISUAL STUDIO 2019 Finally, Visual Studio 2019 is released and one of the nice features which is generally available now with Visual Studio 2019 is LIVE SHARE. Live Share makes it possible to share the code that you are working on right now and collaborate with fellow developers without using a separate tool. In this post, let's see how we can use Live Share. I have some solution opened in Visual Studio 2019. There you should be able to notice this new button titled LIVE SHARE located at the top

right corner.

Live Share

Once you click on that, you will see a prompt saying Visual Studio will now initiate the Live Share and your firewall will prompt to grant access to required ports. Once that is done, you will see the title of the button changed to Sharing and a link will be copied to

your clipboard.

Sharing

You just need to share the link with the other user. Once he/she has the link, he/she need to open up the link in a browser.

Open Sharing

Now I am switching to my other machine and have Visual Studio 2019

installed there.

As soon as I navigate to the link from a browser, I am prompted to open the link in an application. Here the possible applications are either Visual Studio 2019 or Visual Studio Code. I am selecting Visual

Studio.

Now the shared solution will get opened in Visual Studio and it's just like I have the original solution running in my machine. I can see when the other person is highlighting the code, when he is doing any changes etc, it's almost instantaneous. I can also see the email of the other user at the cursor point. So imagine there are many users connected to the session, I will see who is doing what.

Sharing

And if I switch back to the machine which I initiated sharing, you can also share the terminal with participants in Read-Only or

Read/Write mode.

Options

And finally, you can end the Live Share session, and your participants will get notified.

Session Ended

Once the sharing session is ended, your participants will no longer have access to the solution. This is a really handy feature. Do try it out.

Happy Coding.

Regards,

Jaliya

Posted by Jaliya Udagedara at 1:38 PM

0 comments

Email This

BlogThis!

Share

to Twitter

Share

to Facebook

Share

to Pinterest

Reactions:

TUESDAY, APRIL 2, 2019 .NET CORE WORKER SERVICES With .NET Core 3.0, you can create long running services as background services. With .NET CORE 3.0.100-PREVIEW3, a new template is introduced named Worker Service. These services can be used to do things like processing messages in a queue, as a watcher etc. In this post, let's see how we can get started on creating a Worker Service. For this you will need to have VISUAL STUDIO 2019 and .NET CORE 3.0.100-PREVIEW3 installed in your machine. Remember to use .NET Core 3.0 with Visual Studio, you'll anyway need Visual Studio 2019 (By the way, Visual Studio 2019 RTM is getting released today, which I am very excited about). Once those are installed, you can create a new ASP.NET Core Web Application. If you are wondering why do you need to create a Web Application, the reason is, currently the Worker template is sitting inside Web Application template and this is going to get changed in the future. The Worker Service template will be available directly inside the create new project wizard. ASP.NET Core Web Application Configure your new project After giving the solution and project name, in the next dialog, you can see the WORKER SERVICE template. Make sure you have selected .NET CORE and ASP.NET CORE 3.0 as the target framework. Worker Service Template When the project is created, you can see two classes are created, first one is the familiar PROGRAM.

Program.cs

public class Program

{

public static void Main(string args)

{

CreateHostBuilder(args).Build().Run();

}

public static IHostBuilder CreateHostBuilder(string args) => Host.CreateDefaultBuilder(args) .ConfigureServices(services =>

{

services.AddHostedService();

});

}

This is similar to what we used to in ASP.NET Core Web Applications, instead it directly configures services adding a service of any type which implements IHOSTEDSERVICE. Here it's a type of a WORKER.

Worker.cs

public class Worker : BackgroundService

{

private readonly ILogger _logger; public Worker(ILogger logger)

{

_logger = logger;

}

protected override async Task ExecuteAsync(CancellationToken stoppingToken)

{

while (!stoppingToken.IsCancellationRequested)

{

_logger.LogInformation($"Worker running at: {DateTime.Now}"); await Task.Delay(1000, stoppingToken);

}

}

}

WORKER implementing an abstract class BACKGROUNDSERVICE which in turn implements IHOSTEDSERVICE. Now if you run this, the message will get displayed until we issue an cancellation token, for instance until you press CTRL + C etc. Now you can use this to create a Windows Service or to use as a Linux Daemon with some very little changes.

Hope this helps.

Happy Coding.

Regards,

Jaliya

Posted by Jaliya Udagedara at 1:18 PM

0 comments

Email This

BlogThis!

Share

to Twitter

Share

to Facebook

Share

to Pinterest

Reactions:

MONDAY, APRIL 1, 2019 RUNNING SQL SERVER INSIDER A DOCKER CONTAINER Most of the time when we are working with an application which connects to a Microsoft SQL Server database, we usually have Microsoft SQL Server installed in the local machine and have our test database/s there and doing our testing against that. With SQL Server containers you can avoid the installation and you can set up a SQL Server in a matter of minutes. In this post, let’s see how we can setup SQL Server 2019 inside a Docker container. As of today, the latest SQL Server 2019 image is CTP

2.4.

First, make sure docker daemon is running in your machine. I am on Windows and it’s making sure Docker Desktop is running. Now pull up the image from MCR (Microsoft Container Registry). If you are not aware that Microsoft has started maintaining its own container registry (like Docker Hub) and has started serving container images from there. You can find more information on that from this blog post: Microsoft syndicates container catalog

).

I am using POWERSHELL. docker pull mcr.microsoft.com/mssql/server:2019-CTP2.4-ubuntu Once the command is completed, you can run the following command to make sure the image is present.

docker images

docker images

Next, before starting a container from this image, you need to accept end user license and setup a SA password. You can do all this and start up a container by below command. docker run -e 'ACCEPT_EULA=Y' -e 'SA_PASSWORD=1qaz!QAZ@' -p 1433:1433 --name sql2019 -d mcr.microsoft.com/mssql/server:2019-CTP2.4-ubuntu After that if you check on running containers, you should see our SQL2019 container is running.

docker ps -a

Now you have a container which has SQL Server is running. Next thing you might want is to try the connectivity. In this post I am using Microsoft SQL Server Management Studio (SSMS). I just need to get the local IP address of my machine and use it as the server name, use SQL Server Authentication and use SA

credentials.

SSMS - Connected

It should get connected without any issues. Now if you want to restore a database, you can use either SSMS or SQLCMD. For this post,

I will use SSMS.

When I try to select a .BAK file, of course, it’s empty.

Locate Backup File

I can easily copy the file I want using DOCKER CP command. docker cp C:\Users\Jaliya\Desktop\WideWorldImporters-Full.bak :/var/opt/mssql/data Once the command completed, if I refresh the Locate Backup File dialog, I can see the copied file there. And from there I can select the file and do the restoration. A couple of important things,

*

You can stop the container (in this case: DOCKER STOP SQL2019) and start (DOCKER START SQL2019) it later without losing the changes in SQL Server Configuration and your databases.

*

But if you remove the container by doing a DOCKER RM, everything in the container is deleted, including your databases. That’s pretty neat, isn’t it. Hope this helps.

Happy Coding.

Regards,

Jaliya

Posted by Jaliya Udagedara at 12:54 PM

0 comments

Email This

BlogThis!

Share

to Twitter

Share

to Facebook

Share

to Pinterest

Reactions:

SUNDAY, MARCH 31, 2019 VISUAL C# AND ASP.NET TECHNICAL GURU - FEBRUARY 2019 Another month as a judge in Microsoft TechNet Guru Awards. And this it’s under both Visual C# and ASP.NET category. The TechNet Guru Awards celebrate the technical articles on Microsoft TechNet. Post in WikiNinjas Official Blog, https://blogs.technet.microsoft.com/wikininjas/2019/03/31/technet-guru-winners-february-2018/ Visual C# Technical Guru - February 2019 Well, this time under Visual C# there were not many articles as it was used to be. Got into judging ASP.NET Category as well. ASP.NET Technical Guru - February 2019

Happy Coding.

Regards,

Jaliya

Posted by Jaliya Udagedara at 11:10 PM

0 comments

Email This

BlogThis!

Share

to Twitter

Share

to Facebook

Share

to Pinterest

Reactions:

MONDAY, MARCH 4, 2019 IASYNCENUMERABLE IN C# 8 Before C# 8, if you want to iterate over a collection, the data for that collection needs to be ready before iteration. Basically, something like this was not possible prior to C# 8. private static async IEnumerable GetDataAsync()

{

for (var i = 0; i < 10; i++)

{

yield return await GetDataAsync(i);

}

}

What you can do is something like below. private static IEnumerable GetDataAsync()

{

for (var i = 0; i < 10; i++)

{

yield return GetDataAsync(i).Result;

}

}

But this will cause a thread block. With C# 8 comes the IASYNCENUMERABLE which makes the yield return asynchronous. private static async IAsyncEnumerable GetDataAsync()

{

for (var i = 0; i < 10; i++)

{

yield return await GetDataAsync(i);

}

}

You can see that even though it’s an ASYNC method, it’s not returning a TASK anymore. You can iterate over an IASYNCENUMERABLE using AWAIT FOREACH making it an async stream. await foreach (var item in GetDataAsync())

{

Console.WriteLine(item);

}

Isn’t it nice.

Happy Coding.

Regards,

Jaliya

Posted by Jaliya Udagedara at 11:05 AM

0 comments

Email This

BlogThis!

Share

to Twitter

Share

to Facebook

Share

to Pinterest

Reactions:

THURSDAY, FEBRUARY 28, 2019 VISUAL C# AND ASP.NET TECHNICAL GURU - JANUARY 2019 Another month as a judge in Microsoft TechNet Guru Awards. And this it’s under both Visual C# and ASP.NET category. The TechNet Guru Awards celebrate the technical articles on Microsoft TechNet. Post in WikiNinjas Official Blog, https://blogs.technet.microsoft.com/wikininjas/2019/02/27/the-microsoft-technet-guru-awards-january-2019/ Visual C# Technical Guru - January 2019 Well, this time under Visual C# there were not many articles as it was used to be. Got into judging ASP.NET Category as well. ASP.NET Technical Guru - January 2019

Happy Coding.

Regards,

Jaliya

Posted by Jaliya Udagedara at 2:20 PM

0 comments

Email This

BlogThis!

Share

to Twitter

Share

to Facebook

Share

to Pinterest

Reactions:

TUESDAY, FEBRUARY 19, 2019 WROTE A POST ON WIKI LIFE AT OFFICIAL BLOG OF TECHNET WIKI Wrote a post in Wiki Ninjas - Official Blog of TechNet Wiki . The title of the post is TNWIKI ARTICLE SPOTLIGHT – BLAZOR: CREATING A REUSABLE GRID

COMPONENT.

TNWiki Article Spotlight – Blazor: Creating A Reusable Grid

Component

Read the rest on,

TNWiki Article Spotlight – Blazor: Creating A Reusable Grid

Component

Happy Coding.

Regards,

Jaliya

Posted by Jaliya Udagedara at 2:27 PM

0 comments

Email This

BlogThis!

Share

to Twitter

Share

to Facebook

Share

to Pinterest

Reactions:

SUNDAY, FEBRUARY 3, 2019 VISUAL C# TECHNICAL GURU - DECEMBER 2018 Another month as a judge in Microsoft TechNet Guru Awards under Visual C# category. The TechNet Guru Awards celebrate the technical articles on Microsoft TechNet. Post in WikiNinjas Official Blog, https://blogs.technet.microsoft.com/wikininjas/2019/02/02/technet-guru-winners-dec-2018-02-02-is-double-delight-day/ Visual C# Technical Guru - December 2018

Happy Coding.

Regards,

Jaliya

Posted by Jaliya Udagedara at 5:40 AM

0 comments

Email This

BlogThis!

Share

to Twitter

Share

to Facebook

Share

to Pinterest

Reactions:

SATURDAY, FEBRUARY 2, 2019

.NET CORE TOOLS

.NET Core Tools was initially introduced with .NET Core 2.1

.

Basically .NET Core tools are .NET Core console apps that are packaged and distributed as NuGet packages and is similar to NPM global tools

.

Up to the release of .NET Core 3 Preview 1.0 back in December 2018, .NET Core tools are global meaning once installed, they are available from any location on the machine for the current user. But this did not allow the different tools version to be selected per location. Say for one repository you want the specific tool version of A, and for another repository, you want the version B, it wasn’t possible, but that’s until the release of .NET Core 3

Preview 2.0

.

With .NET Core 3 Preview 2.0 which was released last week (29th January 2019), you can now maintain .NET Core tools locally as well as

globally.

In this post, let’s have a look at how we can achieve that.

dotnetsay

is a very basic .NET Core tool Microsoft has developed (you can find some nice set of tools here in this repo: natemcmaster/dotnet-tools

). For this demo,

let’s use the tool DOTNETSAY. .NET CORE GLOBAL TOOLS To install a tool globally you can use the dotnet tool install command with --GLOBAL/-G flag. dotnet tool install -g dotnetsay --version 2.1.4 To run the tool you can use just say DOTNETSAY from the command prompt. Note: this is the TOOLCOMMANDNAME which is configured in the

tool.

dotnetsay

To list all of the tools, use dotnet tool list

.

dotnet tool list -g

dotnet tool list -g

To update a tool, use dotnet tool update

.

dotnet tool update -g dotnetsay And to uninstall, dotnet tool uninstall

.

dotnet tool uninstall -g dotnetsay Basically --GLOBAL/-G flag means the .NET Core tools at the machine

level.

.NET CORE LOCAL TOOLS To install a .NET Core tool to a specific location, you can use the

--TOOL-PATH flag.

dotnet tool install dotnetsay --tool-path "C:\Users\Jaliya\Desktop\dotnet-tool-dotnetsay" The above command will install DOTNETSAY latest version to a folder named DOTNET-TOOL-DOTNETSAY in my Desktop. With .NET Core Local tools, there comes this concept of a manifest file. You can define a manifest file which is a json file at your folder and define all the tools and their versions you like to have it there. To create the manifest file, you can run the following command. dotnet new tool-manifest Once you run this command, you can see a folder created named .CONFIG. There inside, you can see a json file created named DOTNET-TOOLS.JSON which has the following structure.

{

"version": 1,

"isRoot": true,

"tools": {}

}

Now sitting inside your folder (DOTNET-TOOL-DOTNETSAY here in my case) run the following command. dotnet tool install dotnetsay And now you should see the dotnet-tools.json file is updated as

follows.

{

"version": 1,

"isRoot": true,

"tools": {

"dotnetsay": {

"version": "2.1.4",

"commands":

}

}

}

To run local tools, you can’t execute TOOLCOMMANDNAME just like you did for global tools. For that, you need to use DOTNET TOOL RUN

command.

dotnet tool run dotnetsay To see all your local tools, run dotnet tool list.

dotnet tool list

And you can see the following output.

dotnet tool list

There you can see which manifest is being used. One of the important things to note is, if you don’t have a manifest file inside a folder, to install a local tool, you need to specify --TOOL-PATH flag.

Hope this helps.

Happy Coding.

Regards,

Jaliya

Posted by Jaliya Udagedara at 10:42 AM

0

comments

Email This

BlogThis!

Share

to Twitter

Share

to Facebook

Share

to Pinterest

Reactions:

Older Posts

Home

Subscribe to: Posts (Atom) DEVELOPER TECHNOLOGIES

WIKI NINJA

FOLLOW ME ON TWITTER

ABOUT ME

* Jaliya Udagedara

View my complete profile

BLOG ARCHIVE

* ▼  2019 (27)

* ▼  October (1) * .NET Core: Tiered Compilation

* ►  September

(2)

* ►  August (2)

* ►  July (4)

* ►  June (3)

* ►  May (2)

* ►  April (5)

* ►  March (2)

* ►  February (4) * ►  January (2)

* ►  2018 (51)

* ►  December (4) * ►  November (5) * ►  October (3)

* ►  September

(5)

* ►  August (3)

* ►  July (3)

* ►  June (5)

* ►  May (5)

* ►  April (6)

* ►  March (4)

* ►  February (1) * ►  January (7)

* ►  2017 (37)

* ►  December (2) * ►  November (5) * ►  October (2)

* ►  September

(2)

* ►  August (3)

* ►  July (2)

* ►  June (4)

* ►  May (5)

* ►  April (2)

* ►  March (3)

* ►  February (3) * ►  January (4)

* ►  2016 (45)

* ►  December (3) * ►  November (2) * ►  October (2)

* ►  September

(6)

* ►  August (3)

* ►  July (4)

* ►  June (6)

* ►  May (4)

* ►  April (2)

* ►  March (2)

* ►  February (6) * ►  January (5)

* ►  2015 (48)

* ►  December (2) * ►  November (2) * ►  October (3)

* ►  September

(3)

* ►  August (3)

* ►  July (5)

* ►  June (5)

* ►  May (4)

* ►  April (8)

* ►  March (5)

* ►  February (4) * ►  January (4)

* ►  2014 (63)

* ►  December (6) * ►  November (2) * ►  October (6)

* ►  September

(6)

* ►  August (4)

* ►  July (3)

* ►  June (6)

* ►  May (6)

* ►  April (2)

* ►  March (6)

* ►  February (9) * ►  January (7)

* ►  2013 (59)

* ►  December (7) * ►  November (5) * ►  October (7)

* ►  September

(6)

* ►  August (3)

* ►  July (6)

* ►  June (6)

* ►  May (7)

* ►  April (3)

* ►  March (2)

* ►  February (3) * ►  January (4)

* ►  2012 (62)

* ►  December (6) * ►  November (3) * ►  October (6)

* ►  September

(11)

* ►  August (2)

* ►  July (5)

* ►  June (2)

* ►  May (4)

* ►  April (4)

* ►  March (8)

* ►  February (7) * ►  January (4)

* ►  2011 (42)

* ►  December (2) * ►  November (2) * ►  October (1)

* ►  September

(4)

* ►  August (2)

* ►  July (1)

* ►  June (8)

* ►  May (4)

* ►  April (3)

* ►  March (8)

* ►  February (5) * ►  January (2)

* ►  2010 (6)

* ►  November (4) * ►  October (2)

* ►  2009 (5)

* ►  December (1) * ►  November (4)

MY CERTIFICATIONS

UNIQUE VISITORS

1,056,855

LABELS

* .NET Core

(30)

* .NET Framework

(232)

* ADO.NET

(8)

* Android

(2)

* AngularJS

(6)

* Apps for SharePoint

(4)

* ASP.NET

(49)

* ASP.NET Core

(31)

* ASP.NET Web API

(6)

* Azure

(7)

* Bing Maps

(5)

* Business Intelligence

(2)

* C/C++

(5)

* C# (246)

* Docker

(9)

* EF Core

(3)

* Entity Framework Core

(1)

* Exchange 2010

(1)

* Eye Tracking

(2)

* Face Recognition

(2)

* Face Tracking

(2)

* FBCMD

(1)

* GitHub

(1)

* InfoPath

(4)

* IronPython

(1)

* JavaScript

(3)

* jQuery

(5)

* MacOS

(4)

* Microsoft

(60)

* Microsoft SQL Server

(28)

* Microsoft Sync Framework

(4)

* Microsoft Visual Studio

(20)

* Miscellaneous

(1)

* React

(3)

* Scripting Languages

(2)

* Sessions

(26)

* SharePoint

(24)

* SharePoint 2010

(20)

* Silverlight

(15)

* Syncfusion

(1)

* TechNet Wiki

(93)

* TypeScript

(3)

* WCF (18)

* Windows Runtime Apps

(35)

Jaliya Udagedara. Awesome Inc. theme. Powered by Blogger

.