by prabakaranr, 2019-08-21T11:45:50.607Z
Form this blog post, learn how to consume the ASP.NET Core Web (or REST) APIs in Xamarin.Forms application.
by bill-s, 2019-08-19T23:26:54.912Z
In this post, I show how you could implement a plugin system that can unload the plugins dynamically. I also provide some background information behind the techniques and classes involved. Unlike the AppDomain, the AssemblyLoadContext lets you unload the plugin types and the owned assemblies - sounds promising, right?
by cezarypiatek, 2019-08-19T15:18:39.785Z
I’ve decided to create a series of blog posts where I will present what I’ve recently learned about the traps related to the multithreading in C#. I will also show you my proposition of Roslyn analyzers that can possibly help to avoid those issues right at the stage of writing the code. This part is about choosing a suitable object for locking.
by dnwuQTLI06qsA, 2019-08-22T01:17:27.104Z
On Thursday, August 8, 2019, GitHub announced the preview of GitHub Actions with support for Continuous Integration and Continuous Delivery (CI/CD). Actions makes it possible to create simple, yet powerful pipelines and automate software compilation and delivery. Today, we are announcing the preview of GitHub Actions for Azure.
With these new Actions, developers can quickly build, test, and deploy code from GitHub repositories to the cloud with Azure.
by dnwuQTLI06qsA, 2019-08-22T01:15:21.817Z
Welcome to Azure Tips and Tricks, this site is a special collection of over 180+ tips, videos, conference talks, and 2 eBooks that span the entire universe of the Azure platform. The tips you'll find here are based on real-world scenarios that the community has encountered while using Azure. Feel free to jump in and come back weekly for new tips! - Michael Crump (@mbcrump)
by bill-s, 2019-08-19T23:29:07.044Z
Recently got chances to work on Azure DevOps for Desktop (UWP/WPF/Desktop Bridge/MSIX) , and often need to CI/CD .Net Core and .Net Standard. Most of them are related to SDK setup, NuGet version update, TargetPlatform settings, or Code Sign Certificate trust. This article is to give quick references on how to solve common CI issues for this scenario.
by bill-s, 2019-08-19T23:26:08.063Z
In Part 1, we explored why front-end performance is an essential ingredient for any website serious about achieving its goals. We then learned about the common metrics which are used to measure major performance as well as some for the best tools to collect this data for you.
Now that we know how to measure and understand a website’s current performance, in Part 2, we’re going to talk about some of the recommended front-end performance optimization techniques you can use to improve it. All of these can be built into your web development workflow starting today.
by bill-s, 2019-08-19T23:29:44.027Z
Regular visitors of my blog will know that I’ve written a lot of posts about the HttpClientFactory feature, available in the Microsoft.Extensions.Http package which simplifies the consumption and proper lifetime usage of HttpClient instances.
Recently, I’ve begun digging into gRPC and I’m pleased to see a similar pattern is available for gRPC-based communication.
In this post, I want to show a quick example of how to get started with the gRPC Client Factory. I’m going to focus on adding this to an ASP.NET Core 3.0 web project, which will act as a client of an external gRPC service. This post assumes a little knowledge about gRPC. You can read my earlier blog post (slightly outdated now) which covers some extra ground.
by dnwuQTLI06qsA, 2019-08-22T01:14:19.968Z
Today I’m thrilled to announce that a Beta release for the next version of Microsoft Edge is now available for all supported versions of Windows and macOS. Our goal with Microsoft Edge is to create better web compatibility with better performance for our customers while ensuring less fragmentation of the web for all web developers. Our community has been with us on this journey from the beginning and your feedback is making it possible to rapidly improve. To date, there have been more than one million downloads of our preview builds, across all supported versions of Windows and Mac, from which we have received more than 140,000 individual pieces of feedback. Thank you!
by dnwuQTLI06qsA, 2019-08-22T01:29:32.455Z
Postman is a great tool to explore REST APIs. You can build requests and try them out to get quick feedback. Then you can persist them as collections to make sure that the knowledge doesn't get lost.
Newman, the CLI version of Postman, allows you to take it to the next level and transform a collection into a suite of automated end-to-end tests. This suite will run then in your CI tool of choice. In this article, I will explore the benefits of doing so and show you how to set it up.
by dnwuQTLI06qsA, 2019-08-22T01:32:25.969Z
Why was this made?
Originally, JazSharp was only aiming to be a mocking framework but after the initial implementation attempts proved to be unreliable, the scope increased to be a full unit testing framework.
The benefits of JazSharp over other mocking frameworks are:
No reliance on interfaces or similar layers of separation that are not motivated by clean development practises.
No issues when testing code that changes static/global values for the app - statics methods and properties can be mocked just like any method.
An alternative approach to defining mocks. This is less of a benefit and more of a personal preference. For example, parameters can be checked after a mock is called and defining a mock is quick and easy.
The syntax used to define test methods is also very different from other .Net testing frameworks and allows test names (or descriptions in the case of JazSharp) to read more clearly both to technical and non-technical persons.
by bill-s, 2019-08-19T23:23:52.404Z
Logging is a big part of software development for many years now. One can argue that a logging mechanism is a must-have part of any application or library. I would agree with that statement.
Logging has a crucial part to play in a scenario where you can’t use interactive debugging (that is, attaching a debugger like Visual Studio). It allows us to investigate errors after the problem already happened. In some cases, like Production Debugging, logs might be the only information you have.
by bill-s, 2019-08-19T23:30:46.721Z
Table of contents
Section 0: The Golden Rule
Single advice that inspires all the others (1 special bullet)
Section 1: The Test Anatomy
The foundation - structuring clean tests (12 bullets)
Section 2: Backend
Writing backend and Microservices tests efficiently (8 bullets)
Section 3: Frontend, UI, E2E
Writing tests for web UI including component and E2E tests (11 bullets)
Section 4: Measuring Tests Effectiveness
Watching the watchman - measuring test quality (4 bullets)
Section 5: Continous Integration
Guidelines for CI in the JS world (9 bullets)
by dnwuQTLI06qsA, 2019-08-22T01:30:46.101Z
There are over 300 million fraudulent sign-in attempts to our cloud services every day. Cyberattacks aren’t slowing down, and it’s worth noting that many attacks have been successful without the use of advanced technology. All it takes is one compromised credential or one legacy application to cause a data breach. This underscores how critical it is to ensure password security and strong authentication. Read on to learn about common vulnerabilities and the single action you can take to protect your accounts from attacks.
by tpeczek, 2019-08-21T07:35:29.276Z
This post describes an attempt to build a proof-of-concept RSocket server by putting together RSoket.NET and new ASP.NET Core networking primitives for non-HTTP servers.
by dnwuQTLI06qsA, 2019-08-22T01:29:59.608Z
This is the seventh part in a series of articles. If you’re not familiar with Durable Functions you should check out the previous articles before reading this.
There are a number of patterns that Durable Functions make easier to implement, we’ll look at some more later in this series of articles.
One common scenario is the requirement to create a “pipeline” of processing where the output from one Azure Function feeds into the next function in the chain/pipeline. This pattern can be implemented without Durable Functions, for example by manually setting up different queues to pass work down the chain. One downside to this manual approach is that it’s not sometimes immediately obvious what functions are involved in the the pipeline. Function chaining with Durable Functions allows the chain/pipeline to be easy to understand because the entire pipeline is represented in code.
To implement the function chaining pattern, you simply call one activity function and pass in the input from a previous activity function.