DEV Community: Zohar Peled

Result.Simplified now live on nuget

Zohar Peled — Tue, 29 Apr 2025 09:23:29 +0000

A few years back I've decided to create a Result and Result<T> classes to handle a situation in my code - I've had a couple of classes that contained methods with expected points of failures, but couldn't inject a logger into these classes (well, technically I could, but it was prohibited by the architect in charge).

The solution I came up with was to use a couple of classes to enhance the return value of these methods - the Result and Result<T> classes which I've blogged about in 2021

So this project was collecting dust as a GitHub repository for a while, before I found out that this is an actual known pattern adopted into C# from functional programming - and that pattern actually has quite a few implementations - like Amichai Mantinband's ErrorOr which is a great implementation that offers a very rich API.

Lately I've needed to use the result pattern again, and as I was searching for an implementation that was accurate for my needs, I came to realize that my old ResultOf project was just what I needed - nothing less, nothing more. I mean, I could go with ErrorOr or any other implementation, but they all seemed to be a bit of an overkill for my specific need.

So I did what any other reasonable developer did and tried to upload my existing project to Nuget - however, it turned out the package id ResultOf was already in use (with another implementation that wasn't exactly what I wanted) so I named it Result.Simplified.

One thing led to another and 16 days later I'm at version 2.1.0, with a 100% test coverage, a newly created repository, and almost 700 downloads.

If you've made it so far I would love to get some feedback on it, if that's not too much to ask :-)

AI based technical interview questions generator

Zohar Peled — Tue, 18 Mar 2025 09:09:42 +0000

First published on What The # Do I Know?

TL;DR
If you don't want to read the background story, skip to the end.

Why do we need it?

It's no secret that good technical interviews are hard to create.
IMHO, this is one of the main reasons why so many technical interviews and coding challenges nowadays suck. I've been looking for a new job lately after a little over seven years of continuous employment and out of around 30 technical interviews, only three were the kind of interviews where the interviewer could actually learn how I would perform on the job.
Now, this issue isn't new - in fact, I've blogged about it back in 2019, but unfortunately, not only did things not get better, they actually got worse.
This is frustrating not only for me as a candidate but also for the interviewer - because, let's face it, these kinds of questions are rarely relevant to your day-to-day work.

Many technical interviews are simply a collection of LeetCode questions, which poses several problems for the interviewer: If the candidate provides the correct answer, how do you know it's not because they've searched for solutions to popular interview questions a day before the interview? or because they saw you were asking that question on Glassdoor, or some other candidate told them what questions to expect? And don't even get me started on the relevance of at least some of these questions to your day-to-day work in the position you're interviewing for!

So, one way to fix this is to actually take the time and invest the energy to build a good technical interview, one that will fit the position you're looking to fill so much better, that people who pass it are more likely to succeed in this position - but as I've said in the first sentence - this is hard. Really hard. And who's got the time for this anyway? I mean, if you're searching for someone to join your team, it's not because your team suffers from too much free time and not enough work, right?

Building the application

For this, I've used Base44 and got an MVP up and running in literally no time. I mean, if I had to build it all manually it probably would have taken me about a week - not counting the time I’d need to learn React (which is still on my to-do list; I plan to get there someday).
With Base44 it was ready in a matter of minutes, with just a couple of prompts.
Since it was so easy, I decided to add more options. I went back to ChatGPT, created a few more prompts, then used Base44 to generate additional question types.

As of now, the application contains 4 different options to generate technical interview questions:
debugging questions, refactoring questions, code review questions and questions that are based on feature requirements. And the icing on the cake - You can actually view and edit the prompt before sending it to AI, or even copy it to use with your own favorite AI provider.

So why should you use it?

You'll never have to worry again if the candidate copied the answer from somewhere.
You'll never have to worry again that the questions aren't reflecting the day-to-day work.
You can generate new questions anytime, based on either your own code or generated one - in a matter of minutes.
You can tailor your own technical interview with minimal effort, ensuring that it matches the exact needs you have for any developer position at any level.

Please, take it for a spin and let me know what you think. Did you like it? Do you think it's something you can actually use for your own interviews? Is there anything you would like to change or add to it?
I would be very grateful if you could leave a comment on this page or contact me for any suggestions.

AutoEntityGenerator – my first visual studio extension.

Zohar Peled — Tue, 16 Jul 2024 10:56:00 +0000

(First published on What The # Do I Know?)

TL;DR – There are links to the Visual Studio Marketplace and the GitHub repository at the end.

It all started when I watched a YouTube video by Amichai Mantinband called Controllers From Scratch Using .NET 8,
where he shows how to properly design and build an ASP.NET Controller as a part of his ASP.NET 8 REST API Tutorial. (As a side point, I highly recommend subscribing to his YouTube channel).

One of the things he talked about in this video, was the structure of end points he follows and recommend – and this structure has three parts:

Mapping from request object to domain model
Acting on the domain model
Mapping the result of that action to a response object
The example he shows is creating a product, so let me quickly show you the code for this example:

public IActionResult Create(CreateProductRequest request)
{
    // mapping request to domain
    var product = request.ToDomain();

    // acting on domain object
    _productService.Create(product);

    // mapping domain to response and return to client
    return CreatedAtAction(
        actionName: nameof(Get),
        routeValues: new { ProductId: product.Id },
        value: ProductResponse.FromDomain(product)
    );
}

Of course, in this video he creates the domain model, the different request and response DTOs, and the mapping methods between them – and this is what gave me the idea for my extension – which is a very simple idea: What if, instead of having to manually write all these DTOs and mappings, we would have a light bulb action that will generate all this code for us with just a few mouse clicks, using a simple form like the “Extract interface” form?

Armed with this idea and zero knowledge about visual studio extensions, I’ve called ChatGPT for help (and then also involved Claude.AI). The beginning was somewhat difficult since both of them sent me off to somewhat misleading directions, but after a few trials and errors, I’ve managed to get started with a simple POC that shows a light bulb menu item.
After that POC up and running it was time to start focusing on what I wanted the extension to do.

The first step was to get the menu item to only show when using the light bulb on a class or record definition – which was quite simple. Then I’ve used a lot of ChatGPT’s help with getting the information I needed from the code – the namespace, the class (or record) name, its constructors,
public properties, type parameters and other relevant information,
all collected into a class I’ve called Entity (and a bunch of other classes to go along with it such as Property, Namespace and so on):

public class Entity
{
    public Project Project { get; set; }
    public Namespace Namespace { get; set; }
    public string Name { get; set; }
    public List<Constructor> Constructors { get; set; }
    public string SourceFilePath { get; set; }
    public List<Property> Properties { get; set; }
    public List<string> TypeParameters { get; set; }
    public List<string> GenericConstraints { get; set; }
}

Getting the entity information was basically a simple mapping between Microsoft.CodeAnalysis.CSharp.Syntax definitions to my own definitions, but it is a crucial step of the process.
The next step was to build the UI, which contains a form where the user can select which properties they want to include in the DTO, how to name it, what would be its file name, what directory to save it to, and which direction to generate the mapping.

The next step was to use the information from the UI to generate a new Entity object that represents the DTO, use then use that entity and the original one to generate the code for both the DTO and the mappings, and finally, save that code in new files in the user-selected directory.

It took me about 3-4 weeks of part-time work (about 25-30 work hours a week) to get the first version to a point I feel good enough about it to release it to the public – and there’s still quite a bit of work left to do on it, but IMHO it is good enough to work with and therefore good enough to be published.

As of now, it can only be installed on Visual Studio Community 2019 or 2022, but I plan to make it available for Professional and Enterprise editions as well in the (hopefully not too distant) future.

It’s completely open source and free to use, you can check it out on GitHub or in the Visual Studio Marketplace.

If you’ve tried it, I would very much appreciate any feedback, good or bad.

I'm a c# developer, want to start working as a fullstack web. What frontend framework(s) should I learn?

Zohar Peled — Sun, 04 Feb 2024 13:25:42 +0000

Some background: I've started my professional career as a full stack developer back in late 1999, before the term was popular (perhaps even before it was coined?).
I've worked a lot with HTML4, CSS3 and Javascript, but some time around 2009-2010 (I think) I got pulled away from Web dev and got into desktop applications - so while I do have the basic knowledge of how things work, I have no experience whatsoever with current frontend frameworks and technologies (Didn't even had the chance to learn JQuery, when it was the shiny new thing).

So, if I want to land a job as a fullstack developer, what should I learn?

Quick question about code review comments

Zohar Peled — Thu, 28 Apr 2022 15:15:48 +0000

Recently I've started working with an environment that is new to me - the Git repository is stored on Azure dev ops and I'm working on Visual studio 2019.

For every pull request we're having a code review, in which my team leader reviews the code and writes comments (optionally, of course) of what he thinks should be changed.

My question is - Is there a way (and if so how) for me to see these comments directly in Visual studio?

Currently I'm forced to Juggle my attention between VS and the browser showing the PR, and I think it would help a lot if I could just do it all in visual studio.

Thanks and advance,
Zohar.

BTW, sorry for not writing here for so long

Just popped in to let you know

Zohar Peled — Sun, 17 Oct 2021 18:35:41 +0000

Hi,
It's been quite a while since my last post here (and in my own blog, but that's besides the point).

I just popped in to let you know that if you're writing console apps in dot net, you might want to check out my nuget packege ExtendedConsoe.
It has a new version (2.0.0) that helps you write things like menus (single or multiple select), use colors, and read user inputs.

Cheers.

Which do you prefer, and why?

Zohar Peled — Mon, 29 Mar 2021 07:09:02 +0000

Yes, I'm here again with a c# coding style question - and today - between the following different coding styles - which do you prefer and why?

if(condition) single-line-of-code;

if(condition) 
    single-line-of-code;

if(condition) 
{
    single-line-of-code;
}

if(condition) 
    {single-line-of-code;}

if(condition) {single-line-of-code;}

Celebrating 1k downloads of ExtendedConsole

Zohar Peled — Wed, 10 Mar 2021 20:46:23 +0000

ExtendedConsole was the second open source project I've uploaded to GitHub and it's my first public Nuget package.

It was also the subject of my first ever blog post.

I initially uploaded it to nuget in May 2019, since than I've fixed a few bugs and added a few features. Current version is 1.0.5 and was uploaded in December 2019.

This is also the first project I've published a complete documentation to, using DocFx recommended by Shaun Lawrence here on dev.

I know 1k downloads is a much less than what successful packages have in an hour, but I never expected this package to have a lot of downloads to begin with so I'm happy with this number.

Handling non exceptional errors using Result and Result

Zohar Peled — Fri, 05 Mar 2021 22:04:40 +0000

(First published on What the # do I know?)

tl;dr; – Check out the code on GitHub.

Microsoft’s recommendations for handling errors in dot net are published in a page entitled Best practices for exceptions.

In this page there’s a paragraph entitled "Design classes so that exceptions can be avoided", which is a very good advice – If you can design your code to avoid exceptions, you really should.
For instance, if your code contains the mathematical operation of division, you should check the values before hand to avoid having to deal with a
DivideByZeroException thrown at the you by at run time.

However, this page also contains the following recommendation:

Another way to avoid exceptions is to return null (or default) for extremely common error cases instead of throwing an exception. An extremely common error case can be considered normal flow of control. By returning null (or default) in these cases, you minimize the performance impact to an app.

For value types, whether to use Nullable or default as your error indicator is something to consider for your particular app. By using Nullable, default becomes null instead of Guid.Empty. Some times, adding Nullable can make it clearer when a value is present or absent. Other times, adding Nullable can create extra cases to check that aren’t necessary, and only serve to create potential sources of errors.

This is not a bad advice, but what if your writing a void method? What if your method might fail in more than one non exceptional way? returning null doesn’t help you in these situations.
They also suggest, in that page to

Throw exceptions instead of returning an error code.
Exceptions ensure that failures do not go unnoticed because calling code didn’t check a return code.

This is also a good advice, but then again, shouldn’t exceptions be used only in exceptional circumstances? you know, things that you can’t control in your code?

So I’ve decided to solve this problem by using the Result class for void methods, and Result<T> for non-void methods.

Here’s a scenario in which I found it useful to return an instance of Result instead of using a void method:
I needed to take a parameter, get some data based on that parameter from another method, and then send that data to another service – Seems like a fairly simple and common task, right? something like this should do it:

void SendReport(int id)
{
    var report = GetReport(id);
    if (ValidateReport(report))
    {
        SendReport(report);
    }
}

Except that… The SendReport method had several points in which it could fail – for instance, if there was no data corresponding to the parameter, if there was data but it was invalid, if the communication between services was down and so on.
I didn’t need this method to return anything, except I needed to know if it succeeded or failed and if it failed, why.
In this particular case, I couldn’t introduce a logger as a dependency to this method, so I’ve decided to write a class that would help me get that information back from the method, so that I can use it in the code calling this method.

Enter the Result class. This is a very simple class that contains only two properties – A bool indicating success, and a string specifying the error message. The simplified code looks like this:

public class Result
{
    public static Result Success() => new Result();
    public static Result Fail(string errorDescription) => new Result(errorDescription);
    protected Result() => Succeeded = true;
    protected Result(string errorDescription)
    {
        Succeeded = false;
        ErrorDescription = errorDescription;
    }

    public bool Succeeded { get; }
    public string ErrorDescription { get; }
}

Note the result class have no public constructors, only protected ones – you can only initialize it using the static Success or Fail methods. This serves two purposes: One, when you initialize an instance of the Result class, you have a very small chance of initializing it wrong, and two, when you read the code, it’s very clear and unambiguous.

So now, the code from before looks like this:

Result SendReport(int id)
{
    var report = GetReport(id);
    var isValid = ValidateReport(report);
    (isValid.Succeeded)
    {
        return SendReport(report);
    }
    return isValid;
}

Now the calling code can handle whatever went wrong in this method, but there’s just too much code here for such a simple method, right?

I know I can do better – so let me introduce the Result<T> class as well.
This class inherits the Result class and adds a property of type T which is called Value. Like it’s base class, its constructors are also protected and not public, and can only be initialized from static methods.

This class enables me to enhance the value I would return from a non-void method to also include the succeeded indicator and textual error description – so now my code can be simplified to this:

private Result SendReport(int id)
{
    var report = GetReport(id);
    var validationResult = ValidateReport(report);
    return validationResult
        ? SendReport(validationResult.Value)
        : validationResult;
}

The minimalists can see we don’t even need the report variable any more – so the first couple of code lines can be combined into one line (though I wouldn’t recommend that for the sake of readability).

Now let’s take a look on how the ValidateReport method might look like: We know it returns a Result<T>, takes in an instance of T as a parameter, and runs some tests on it. Assume the following code, for example:

private Result<Report> ValidateReport(Report report)
{
    if (report is null) return Result<Report>.Fail("report is null.");
    if (report.SubReports.Count == 0) return Result<Report>.Fail("report has no sub reports.");
    if (string.IsNullOrEmpty(report.Author)) return Result<Report>.Fail("report has no author.");
    if (report.PublishDate <= DateTime.Now.AddYears(-1)) return Result<Report>.Fail("report is too old.");
    return Result<Report>.Success(report);
}

Pretty self explanatory, right? I like that in a code, it’s readable, simple and maintainable.
On the other hand, however, this code is also kind of repetitive, and I’m a big fan of DRY.
So to reduce the amount of repeating in my code, I’ve also overloaded the | and & operators, and to enable short-circuit conditions, I’ve also overloaded the true and false operators.

With this cool new feature I’ve added I can write the code in a more concise manner:

private Result<Report> ValidateReport(Report report)
{
    return IsValid("report is null.", r => r is null)
        && IsValid("report  has no sub reports.", r => r.SubReports.Count == 0)
        && IsValid("report has no author.", r => string.IsNullOrEmpty(r.Author))
        && IsValid("report is too old.", r => r.PublishDate <= DateTime.Now.AddYears(-1));

    Result<Report> IsValid(string errorMessage, Predicate<Report> failPredicate)
        => failPredicate(report)
            ? Result<Report>.Fail(errorMessage)
            : Result<Report>.Success(report);
}

I’ve uploaded the Result and Result<T> classes as a GitHub repository called ResultOf, under MIT licence which basically means everyone can use it for is free.
Both classes are completely documented and the README.md file contains usage examples.

c#9 is finally here (this is not about init-only or records)

Zohar Peled — Sun, 15 Nov 2020 08:13:15 +0000

c# 9 and .Net 5 are finally officially released, and everybody blogs about init-only properties and records - which are very exciting and long-awaited features that I'm sure will be used a lot and contribute a lot to code quality.

However, I would like to address another great thing about c# 9 that I didn't see a lot of bloggers excited about - and that is the improvements of pattern matching. Specifically, the adding of the not keyword - as it relates to an older post I've published almost exactly a year ago:

The perfect non-null test

Zohar Peled ・ Nov 13 '19 ・ 3 min read

#csharp

In c# 9, We finally actually do have the perfect non-null test, and it's way better than x is object because it's much, much more readable:

if(x is not null) { /* No explanation needed... */ }

See when I first started using x is object in my code, My team leader have complained that it's less readable than the x != null we had all over our code base. I actually had to convince him that this is a better option. With the c#9 new syntax, anyone reading the code that has even minimal knowledge of c# and the English language can instantly understand it - which finally, makes it truly the perfect non-null test.

Fashionably late but I've finally joined Twitter

Zohar Peled — Mon, 09 Nov 2020 12:52:33 +0000

I'm not really sure why I did that - I'm not really a social media kind of guy (Don't even have a facebook account). I think it's mainly an effort to stay updated with tech by following .Net groups and professionals, and perhaps another channel to publish What the # do I know.

Role based security database design

Zohar Peled — Sat, 07 Nov 2020 19:51:21 +0000

(First published on What The # Do I Know?

I’ve recently got one more upvote to my second most upvoted answer on StackOverflow, bringing the score of that answer to a nice round figure of 60. This motivated me to write this blog post, in an attempt to improve that answer by adding some background.

I’m not going to explain all there is to know about role-based security – first, because that will require an awful lot of time for me to study this subject extensively and second, well, it’s because I like to keep things as simple as possible.
If you want to learn this in depth you can always start with Wikipedia and see where that takes you.

That being said, we do need a minimal background – so: Role-based security (A.K.A. role-based access control or RBAC) is a security approach that allows access to certain resources (A.K.A securable) based on different roles the authorized users might have.
There are four main entities involved in role based security:

Subject – (A.K.A User) which is the user that use the system. It can be either a human or an automated process – doesn’t matter.
Resource (A.K.A Securable), which is a part of the application which you want to secure.
Permission, which is granted on a resource. Permissions defines the actions that a subject might perform on (or with) a resource.
Role, which is a collection of permissions on a specific collection of resources.

Different permissions might be relevant to different resources – for instance – Suppose your application contains information pages and different forms for the user to fill out – So Read permission is relevant to both information pages and forms, however Write permission is only relevant to forms.

In this post, I’m going to show the design of a very simple permissions approach, which is all or nothing – so I won’t be dealing with permissions at all – the roles are going to be linked to the resources directly – so this design only have three entities: The subject, the role and the resource – and the connections between them would simply be subject to role (many to many), role to resource (many to many) – this means we will need only five tables on our database.

Please note that I’m not going to touch authentication issues in this post, but only describe the authorization system. If you’re not sure what’s what – authentication is the process of identifying a user (usually using a a combination of username / password) and authorization is the process of allowing / denying access to resources.

So – assuming the authentication process is already handled and you have your users table, let’s describe the tables needed for role based authorization.

User (user id (PK), user name (unique), password (salted and hashed!), first name, last name, phone etc’)
Role (role id (PK), role name (unique), role description)
Resources (resource id (PK), resource name (unique))
User To Role (user id, role id) – PK is both columns combined
Role to Resource (role id, resource id) – PK is both columns combined

This database design provides a basic yet flexible role base security, making it super simple to create and maintain different roles – making the entire authorization of your software that much easier.