DEV Community: Frederik Van Lierde

Error Handling in Power Automate Loops

Frederik Van Lierde — Fri, 12 Apr 2024 12:41:14 +0000

When working with automated workflows in Power Automate, we often encounter tasks that need to run repeatedly through loops. A common challenge arises when some of these tasks might fail, for instance, due to external dependencies or unexpected input values. In such cases, allowing the entire flow to fail isn't ideal. Instead, we want to handle these errors gracefully.

Take, for example, a scenario where we're setting permissions for a list of users on SharePoint items. Not all users might be recognized by SharePoint due to various reasons like misspellings or account issues.

If a user isn't found, the action to set permissions fails. However, rather than stopping the whole process, it’s beneficial to capture these errors, continue setting permissions for other users, and send a notification detailing the issues encountered.

This approach ensures that one error doesn't halt the progress of the entire workflow, and we remain informed about which users need our attention. In the upcoming sections, we'll explore how to effectively use Power Automate to manage such errors, ensuring our workflows are both robust and informative.

The Flow

I made a simple flow, as I want to show the basics

The Steps

The main part of the solution is to set the scope (or the action) to execute only when their is a failure

Go to settings of the Scope (or action)
Under Run After, click the arrow
Select Has Failed
De-Select Is successful

Result

When the previous access failed, execute and continue, when the previous action is successful, do nothing and continue with the loop

For Next Loop in PowerAutomate (Easy)

Frederik Van Lierde — Wed, 20 Mar 2024 09:03:21 +0000

We all know the 2 types of loops in PowerAutomate
1. Apply to Each:
This is the primary loop mechanism used in Power Automate for iterating over a collection of items, such as arrays.

When you have a list of items and you want to perform certain actions for each item individually, this is the loop you use. Power Automate takes care of the iteration, applying the actions you've defined to each item in the collection.

2. Do Until:
This loop performs actions repeatedly until a specified condition is met.

It's useful when you're not sure how many iterations you'll need, but you have a clear condition that determines when the loop should stop.

This allows for repeating actions based on dynamic conditions that might change with each iteration of the loop.

What about For Next Loops?

"For Next"-loops are essential when you need to execute a block of code a specific number of times, especially when you're working with indexes or counters.

They provide a precise control mechanism for iterating through a sequence or range of values.

How to create a For Next Loop in PowerAutomate?

The simple trick is to add as Input for an "Apply to Each" action a Range function

Add a "Apply to Each" action to your flow
As Input set "range(0,x)" where x is the number of loops you like to execute

The loop will execute X times.

Power Automate - How to use AutoHeight with Multiline Input Textbox Fields

Frederik Van Lierde — Mon, 18 Mar 2024 08:29:33 +0000

Let's tackle a common challenge for those working with SharePoint lists, especially when dealing with columns that include multiline text.

If you've ever tried to customize these lists, you've likely noticed that the Input Text control doesn't automatically adjust its height based on the content.

This lack of an autoheight feature forces you to set a fixed height for the control.

The downside?
When there's only a line of text, you end up with an excessive amount of unused space. Conversely, if the text spills over multiple lines, the control introduces scroll bars, making the user experience less than ideal.

This article will showcase a solution that seamlessly displays the entirety of the multiline text in both View and Edit modes, eliminating unnecessary scroll bars.

Additionally, when the text box is empty or contains just a single line, it maintains a minimum height, enhancing the form's overall aesthetics and user friendliness.

The following image shows the standard multiline textbox, containing 1 line in edit mode

The following image shows the standard multiline textbox, containing multiple lines in edit mode, as you can see, the user get a scrollbar, which is not user-friendly

The following image shows the the results after the step by step guide, creating a multiline textbox, containing multiple lines in edit mode, with AutoHeight

Step by Step Guide

When the multiline field contains 1 or more lines, the following solution will adapt the Input Text Box accordingly

In your SharePoint click Customize Forms to open Power Apps
Select DataCard for the multiline field
Add Label Input to that DataCard
Set the width the same as the Text Input, as well as the X and Y
Set AutoHeight of the Label Input to true
Set Wrap of the Label Input to true
Set Text of the Label Input to Parent.Default
Set Visible of the Label Input to Parent.DisplayMode = Displaymode.View
Set Visible of the Text Input to Parent.DisplayMode <> Displaymode.View
Set Height of the Text Input to Max(lbl.Height + 16, 100)

Power Automate: How to trigger a flow only when specific field(s) have certain values

Frederik Van Lierde — Wed, 06 Mar 2024 12:50:23 +0000

What is Power Automate

Power Automate is a tool that helps you automate tasks and workflows across your favorite apps and services, without needing any coding skills.

With Power Automate, you can streamline processes, integrate different apps, and automate routine tasks, so you can focus on more important things.

Whether it's sending emails, updating spreadsheets, or triggering notifications, Power Automate makes it easy to automate everyday tasks and boost productivity.

What are Power Automate Triggers?

Power Automate Triggers are like the starting points for your automated workflows. They're the events or actions that kick off a series of tasks or actions within Power Automate. Think of them as the "if this happens, then do that" moments in your workflow.

For example, a trigger could be receiving an email in your inbox, a new file being added to a folder in OneDrive, or a new tweet being posted. These triggers are what signal Power Automate to start running your automated process.

Once a trigger is activated, Power Automate can then perform a sequence of actions, like sending an email, creating a new record in a database, or updating a spreadsheet. Triggers are essential because they determine when your automation begins and what actions it should take based on certain conditions or events.

How to trigger a Power Automate flow ONLY when a specific field has a certain value?

Let's say you're managing a project using a SharePoint list to keep track of tasks, deadlines, and team members.

You want to be instantly notified whenever a task status changes to "Ready To Test" in that list. You don't want the flow to be triggered when a new item is created, or other fields are updated

With Power Automate, you can set up a trigger that activates a workflow whenever a specific column, like "Task Status," is modified in your SharePoint list.

The SharePoint List

The Power Automate Flow

Create a new Flow
Add as Trigger "When an item is created or modified" (SharePoint Action)
Select your SharePoint and List Name

Go to Settings
Add you trigger. In our example, we check if the column Task Status is modified to Ready to Test

@equals(triggerOutputs()?['body']['TaskStatus']?['Value'],'Ready to Test')

Our Task Status column is a choice column with 4 choices.
You can also use the ID of the choice instead of the Text

@equals(triggerOutputs()?['body']['TaskStatus']?['Id'],2)

How to trigger a Power Automate flow ONLY when a 2 columns have a certain value?

In out example, let's add a column Signed Off which is a Yes/No column and we want the flow only executed when Task Status is 'Ready to Test' and Signed Off is true

The solution is to use the and function

@and(equals(triggerOutputs()?['body']['TaskStatus']?['Id'],2),equals(triggerOutputs()?['body']['SignedOff'],true))

Extras

Instead of using the and function you can also use the or function
This solution also work for LookUp and Calculated Columns
In case the user creates a new item, and set the specific fields to the certain values, the flow will work as well.
You can add more columns and make it as complex as needed

How to Check Power Automate Version

Frederik Van Lierde — Mon, 26 Feb 2024 09:29:37 +0000

What is Power Automate?

Power Automate is a tool that helps you automate repetitive tasks and streamline business processes without needing to write code.

Essentially, it's like having a virtual assistant that can handle routine tasks for you. With Power Automate, you can create automated workflows that connect different apps and services, allowing data to flow seamlessly between them.

Whether it's sending notifications, updating spreadsheets, or processing forms, Power Automate empowers you to automate a wide range of tasks, saving you time and effort so you can focus on more important work.

It's a game-changer for boosting productivity and efficiency in both personal and professional settings.

Why Is It Important to Check the Version of Power Automate?

Knowing the version helps you stay informed about any new features, updates, or bug fixes that may have been released. This ensures that you are leveraging the latest capabilities and improvements to optimize your workflows and processes.

Checking the version allows you to ensure compatibility with other tools and services that you may be integrating with Power Automate.

By staying up-to-date with the latest version, you can take advantage of enhanced functionality and security measures, while also ensuring that your automation efforts remain efficient and effective.

How to find the Version of Power Automate?

Go to your Power Automate Environment https://make.powerautomate.com/
Click the Settings (gear button) in the top-right menu
Click View my licenses

Dependency Injection in C#: A Practical Guide for Developers

Frederik Van Lierde — Thu, 25 Jan 2024 14:08:03 +0000

Dependency Injection (DI) is a vital technique in modern C# development, promoting cleaner and more efficient code.

At its core, DI involves supplying objects with their dependencies from outside, rather than having them create dependencies themselves. This concept, while simple, can have profound implications on how you structure and manage your C# applications.

Understanding Dependency Injection through an Example

Let’s take a practical example to understand DI better. Consider a C# application with a class named EmailService that depends on a Logger class to log messages.

Without DI, EmailService might directly instantiate Logger. With DI, Logger is instead provided to EmailService, typically through a constructor, like so:

public class EmailService
{
    private readonly ILogger _logger;

    public EmailService(ILogger logger)
    {
        _logger = logger;
    }
}

This simple shift has powerful implications for your code's flexibility and maintainability.

Key Benefits of Dependency Injection

Reduced Coupling: DI makes classes less dependent on specific implementations of their dependencies, thus promoting looser coupling.
Enhanced Testability: It's easier to test classes by injecting mock dependencies, allowing for more effective unit testing.
Improved Code Maintenance: Changes to dependencies have minimal impact on classes using them, making the codebase easier to maintain.
Increased Flexibility and Scalability: DI makes it easier to swap out implementations or scale the application without major code revisions.

Implementing Dependency Injection in C#

C# developers typically use DI in three ways:

Constructor Injection: The most common form of DI, where dependencies are provided via class constructors.

public class OrderProcessor
{
    private readonly IDatabase _database;

    public OrderProcessor(IDatabase database)
    {
        _database = database;
    }
}

Property Injection: Here, dependencies are set via properties. This is useful when the dependency is optional.
```
public class UserService
{
    public ILogger Logger { get; set; }
}
```

Method Injection: Dependencies are provided through methods. This is less common but useful in specific scenarios.

public class ReportBuilder
{
    public void GenerateReport(IDataReader dataReader)
    {
        // Generate report using dataReader
    }
}

Using DI Frameworks in C#

While you can implement DI manually, using a framework can simplify the process. In C#, popular DI frameworks include:

.NET Core’s built-in Dependency Injection: It's part of the ASP.NET Core framework, making it a natural choice for web applications.
```
public void ConfigureServices(IServiceCollection services)
{
    services.AddTransient<ILogger, ConsoleLogger>();
}
```
Autofac: Known for its flexibility and ease of integration with various .NET platforms.
Ninject: Favored for its syntax and ease of use, particularly in smaller projects.

Conclusion

Dependency Injection is an essential tool in a C# developer's toolkit. By enabling more modular, testable, and maintainable code, DI is more than just a pattern; it's a mindset that encourages thinking about how components in your software interact.

Whether you're working on a large enterprise application or a small personal project, understanding and applying DI principles will undoubtedly enhance your development process and the quality of your software.

.Net BinarySearch is fast, but can we make it faster?

Frederik Van Lierde — Tue, 23 Jan 2024 13:04:39 +0000

The short answer is yes, up to 25%

We all know that in the .Net Framework, the BinarySearch is fast to search in List<>, but can we make it even faster?

The Question

We have a List with 1.000.000 numbers.
We create a function to see if a number exists in the collection

public bool ExistBinarySearch()
{
    return _numbers.BinarySearch(numberToSearch) >= 0;
}

The Faster Binary Search is

public bool ExistFasterBinarySearch()
{
    int low = 0;
    int high = _numbers.Count - 1;

    while (low <= high)
    {
        int mid = (low + high) / 2;
        if (_numbers[mid] == numberToSearch)
            return true;
        else if (_numbers[mid] < numberToSearch)
            low = mid + 1;
        else
            high = mid - 1;
    }
    return false;
}

The Results

The FasterBinarySearch wins.

When and when not to use Extension functions

Frederik Van Lierde — Tue, 23 Jan 2024 09:09:54 +0000

Use extension methods when:

You want to add small, self-contained pieces of functionality to an existing type. Extension methods are ideal for adding simple utility methods that don't require deep integration with the type's structure.
You don't have access to the original source code of the type. If you're using third-party libraries or working with legacy code that you can't modify, extension methods allow you to extend the functionality without having to modify the original code.
You need to add functionality that is specific to a certain context or layer of your application. Extension methods can be used to add layer-specific functionality to domain entities or data transfer objects without cluttering their core behaviour.

Avoid using extension methods when:

The functionality you want to add is complex or tightly coupled to the type's internal structure. Extension methods are not suitable for complex operations that require intimate knowledge of the type's implementation.
The functionality you want to add needs to be overridden in derived classes. Extension methods cannot be overridden, so they are not appropriate for adding functionality that should be tailored to specific derived types.
The functionality you want to add is already available in a more appropriate form, such as a static class or interface method. Extension methods should be used for genuinely new functionality, not for duplicating existing methods or adding complexity to the type's design.

Difference Between Singleton Class vs. Static Class - Recap

Frederik Van Lierde — Wed, 10 Jan 2024 17:00:56 +0000

In C#, understanding the difference between a Singleton class and a Static class is essential for various scenarios in software development. Both have unique characteristics and uses:

Singleton Class

Purpose: A Singleton class ensures that a class has only one instance and provides a global point of access to it. Instantiation: It is instantiated once, and the same instance is reused.
Lazy Loading: Singleton supports lazy loading, meaning the instance is created only when it is needed.
Inheritance: A Singleton can inherit from other classes and implement interfaces.
State: It can maintain state across multiple calls and instances of the application.

Example Use:

Database connections or a file manager where a single instance manages the resources throughout the application.

Static Class

Purpose: A static class is a class that cannot be instantiated. Its members are accessible without creating an object of the class.
Instantiation: Cannot be instantiated. All members are static and accessed directly with the class name.
Lazy Loading: Does not support lazy loading in a conventional way. The class is loaded once by the CLR when it is accessed for the first time.
Inheritance: Cannot inherit from other classes (except for Object) and cannot implement interfaces.
State: Cannot maintain state as it doesn't support instance variables. All members are static.

Example Use:

Utility or helper functions that are generic and don't require object state, like mathematical functions.

Key Differences:

Instantiation Control: Singleton controls the instantiation, allowing only one instance. Static classes are never instantiated.
Memory Allocation: Singleton objects are stored in the heap, while static class objects are stored in the high frequency heap area.
Inheritance and Interfaces: Singleton can implement interfaces and inherit, while static classes cannot.
State Maintenance: Singleton can maintain state, but static classes cannot.

Choosing Between Them:

Use a Singleton when you need a single instance with stateful data across the application.

Use a static class for stateless utility or helper functions that don't require instantiation.

Both Singleton and Static classes promote specific design principles in C#, each serving different purposes based on the requirements of the application.

Why you should never use an UUID as the primary key in SQL Databases

Frederik Van Lierde — Sat, 09 Dec 2023 11:48:14 +0000

Using a UUID (Universally Unique Identifier) as a primary key in SQL databases has both advantages and disadvantages. While UUIDs offer benefits in certain scenarios, there are reasons why they might not be the best choice for a primary key:

Indexing and Performance:
UUIDs are 128 bits long, compared to 32 bits for a typical integer. This larger size can result in increased storage requirements and decreased performance, especially when dealing with large datasets.

Indexes built on UUID columns may not perform as efficiently as those on smaller data types. This is because larger keys can lead to more page reads, impacting query performance.

Readability and Debugging:
Unlike integers, UUIDs are not human-readable, which can make debugging and manual inspection of the database more challenging. Integers or other smaller data types may be more convenient for developers and database administrators.

Clustering:
UUIDs are designed to be globally unique, but they are not guaranteed to be sequential. This lack of sequential ordering can result in suboptimal disk I/O patterns, affecting the performance of certain types of queries, especially those involving range-based searches.

Fragmentation
UUIDs are often generated using a combination of timestamp and random values. This randomness can lead to higher levels of index fragmentation, impacting database performance over time.

Storage Overhead:
Storing UUIDs can lead to increased storage requirements, both in terms of disk space and memory. This can be a concern in environments where storage costs are a critical factor.

Application Complexity:
Managing UUIDs, especially their generation and uniqueness across distributed systems, can add complexity to the application logic. This complexity may not be necessary if simpler primary key types suffice for the application's requirements.

When to Use Flex or Grid (CSS)?

Frederik Van Lierde — Tue, 28 Nov 2023 19:00:02 +0000

In web development, both CSS Flexbox and Grid are powerful tools for creating responsive layouts, but they serve different purposes and are best used in different scenarios:

CSS Flexbox

One-Dimensional Layouts: Flexbox is ideal for one-dimensional layouts where you want to align items either in a row or a column. It's perfect for small-scale layouts.
Alignment and Distribution of Items: Flexbox makes it easy to align items horizontally or vertically and distribute space between items, which is great for navigation bars, footers, or setting up elements in a specific direction.
Dynamic or Unknown Number of Elements: If you have a dynamic or unknown number of elements and want them to fit in a container nicely, Flexbox automatically adjusts the size and order of elements.
Control over the Size of Items: Flexbox offers great control over the size of items, allowing them to grow or shrink to fit the available space.

CSS Grid

Two-Dimensional Layouts: Grid is more suitable for complex two-dimensional layouts where you need to control both rows and columns. It's best for larger-scale layouts.
Precise Layout Control: Grid provides precise control over where you can place items on both axes. You can define the exact placement and size of grid items.
Complex Alignment and Overlapping: Grid allows for more complex alignments and even overlapping of items, which can be useful for certain design layouts.
Creating Consistent Structure: It’s ideal for creating layouts with a consistent structure (like a photo gallery or a dashboard), where elements are aligned in rows and columns.

When to Use Which

Use Flexbox when:
- The layout is simple and linear.
- You need a quick solution for centering items or distributing space.
- The number of items is dynamic or unknown.
Use Grid when:
- The layout is complex and involves rows and columns.
- You need precise control over the placement and sizing of items.
- You are creating a layout with a consistent matrix-like structure.

Combining Both

Often, the best approach is to use both in combination. For example, you might use Grid for the overall page layout and Flexbox for smaller components or individual elements within a grid cell. This combination allows you to leverage the strengths of both layout models.

Azure DevOps Notifications in Slack

Frederik Van Lierde — Mon, 27 Nov 2023 18:25:22 +0000

When a continuous integration system is operational, it's beneficial to ensure that all stakeholders are promptly informed about the successes and failures of deployments.

We can achieve this by utilizing Azure DevOps to send real-time updates to our team members via Slack notifications.

Slack

Create a channel in Slack: Ex. Call it Release Hub
Create an new Slack App: Ex Call it DevOps Notifications
Once the new Slack App has been created, go to Incoming Webhooks , create a new one, select Release Hub
Copy the new generated URL

Azure DevOps

Go to your Project Settings
Click the + icon, and select Slack
Select the Triggers and Filters 4.Copy the Slack WebHook Url (see point 4 above)
Test and Finish

Results

When a build was created, Slack users got this message