Forem: Willy David Jr

Microsoft Ignite Now Open for Registration!

Willy David Jr — Tue, 08 Sep 2020 20:03:12 +0000

Did you love my post?

Good day devs!

Join us at Microsoft Ignite with 48 hours of continuous content and live Q&A – all free!

Microsoft Ignite

Microsoft Ignite is coming directly to you this year. Over 48 hours, you will be immersed in topics with Microsoft leaders, hear from your tech heroes in the digital breakout sessions with live Q&A, technical workshops, 1:1 consultations, and so much more.

Learn new ways to use the cloud, dive into the new technologies, explore innovative development techniques, discover new ways to secure and manage your infrastructure, and more.

Connect with experts who build and support the Microsoft technologies you’re using and evaluating. Join discussions with others in the community to talk thru real-world experiences and shared interests.

Explore the latest in cloud, productivity, collaboration, security, and application development.

Make sure you are registered to gain full access to all sessions, the Connection Zone and Learning Zone activities where you will have the opportunity to connect with peers and experts. Registration is easy and free. Join the conversation on Microsoft Ignite social to keep up-to-date on all event details.

Registration

For full details of schedule and topics, register here.

How to Integrate AutoFac 5 and AutoMapper 10 on your MVC 5 Project using Visual Studio 2019

Willy David Jr — Mon, 31 Aug 2020 17:08:58 +0000

Did you love my post?
Hello devs!

Today we will be integrating AutoFac and AutoMapper to our ASP.NET MVC 5 projects using Visual Studio 2019.

But first, let us know, what these frameworks are.

AutoFac - is a framework mostly used for IoC or Inversion of Controls. This system design is also commonly known as Dependency Injection. DI allows you to build loosely-coupled, testable and maintainable applications. It reduces dependencies among software components and also keeps most of your functionalities reusable. If you want to learn more on DI, I highly recommend Dependency Injection in .NET by Mark Seemann. All types of DI were discussed in the book, with different .NET Solutions included.

AutoMapper - is simply a library to convert another object to similar object. One major example that I can share is that you want to convert your Model class to another ViewModel class that you want to use on your application. We usually do this to hide properties that are not needed, to add additional properties which does not need to modify the main class, and other similar requirements.

So let's get started on implementing both of these. We need to use AutoFac to inject AutoMapper on our Controllers!

First, let's create ASP.NET MVC 5 project using Visual Studio 2019 and add the following packages from NuGet.

AutoFac 5

AutoMapper 10

Next let's add new Module from AutoFac. Here we are adding a new class which inherits from Module class of AutoFac assembly.

using Autofac;
using AutoMapper;

public class AutoFacModule : Module
    {
        protected override void Load(ContainerBuilder builder)
        {
            builder.Register(context => new MapperConfiguration(cfg =>
            {
                //Register Mapper Profile
                cfg.AddProfile<AutoMapperProfile>();
            }
            )).AsSelf().SingleInstance();

            builder.Register(c =>
            {
                //This resolves a new context that can be used later.
                var context = c.Resolve<IComponentContext>();
                var config = context.Resolve<MapperConfiguration>();
                return config.CreateMapper(context.Resolve);
            })
            .As<IMapper>()
            .InstancePerLifetimeScope();
        }
    }

Next let's add the AutoMapperProfile which inherits from Profile of AutoMapper. (The definition of Person and PersonViewModel will be discussed in awhile)

using AutoFacAndAutoMapperMVC.Models;
using AutoMapper;

namespace AutoFacAndAutoMapperMVC.Infrastructure
{
    public class AutoMapperProfile : Profile
    {
        public AutoMapperProfile()
        {
            CreateMap<Person, PersonViewModel>();

            CreateMap<PersonViewModel, Person>();
        }
    }
}

Registration of AutoMapper

After all those configuration, we definitely need to register those configuration on Global.asax file of MVC solution:

protected void Application_Start()
        {
            AreaRegistration.RegisterAllAreas();
            FilterConfig.RegisterGlobalFilters(GlobalFilters.Filters);
            RouteConfig.RegisterRoutes(RouteTable.Routes);
            BundleConfig.RegisterBundles(BundleTable.Bundles);

            var builder = new ContainerBuilder();

            // Register your MVC controllers. (MvcApplication is the name of
            // the class in Global.asax.)
            builder.RegisterControllers(typeof(MvcApplication).Assembly);

            //Register AutoMapper here using AutoFacModule class (Both methods works)
            //builder.RegisterModule(new AutoMapperModule());
            builder.RegisterModule<AutoFacModule>();

            // Set the dependency resolver to be Autofac.
            var container = builder.Build();
            DependencyResolver.SetResolver(new AutofacDependencyResolver(container));
        }

Subsequently, we need to create two classes for our Demo which are Person and PersonViewModel class. Here are the definitions of those two classes:


public class PersonViewModel
    {
        public string FirstName { get; set; }

        public string LastName { get; set; }

        public string Country { get; set; }

        public string MaritalStatus { get; set; }

        public string HighestEducation { get; set; }
    }

public class Person
    {
        public int Id { get; set; }

        public string FirstName { get; set; }

        public string LastName { get; set; }

        public DateTime? DateOfBirth { get; set; }

        public string PhoneNumber { get; set; }

        public string Address { get; set; }

        public string City { get; set; }

        public string State { get; set; }

        public string Country { get; set; }

        public string MaritalStatus { get; set; }

        public string HighestEducation { get; set; }

    }

So what's the purpose of AutoMapper here? Let's say we are getting list of Person from a results set, either from database repository or from an in memory data. And we want to project those results to send to our View page but with different model but with same properties? You might want to do this because you want to hide some properties. You can do this via projection:


//new List<Person>() only assumes that this results came from a results set of Person objects
var model = new List<Person>().Select(x => new PersonViewModel()
            {
                FirstName = x.FirstName,
                LastName = x.LastName,
                Country = x.Country,
                HighestEducation = x.HighestEducation,
                MaritalStatus = x.MaritalStatus
            });

Mapping each properties can be easy but it's not quite productive until you see a long list of properties for every projection that you will make on each of your implementation.

With AutoMapper, you can do this with one code only:


//This entity object can come from Database or any related source
            var person = new Person()
            {
                Id = 1,
                FirstName = "Cecilia",
                LastName = "Chapman",
                Address = "32 West Court Street",
                City = "Dallas",
                State = "GA",
                Country = "USA",
                DateOfBirth = new DateTime(1981, 1, 5),
                HighestEducation = "College Graduate",
                MaritalStatus = "Married",
                PhoneNumber = "+1-541-754-3010"
            };

          var model = _mapper.Map<PersonViewModel>(person);

That was easy, you can easily map two classes with the same properties without doing a long list of projection.

Here's the screenshot of their actual mapping during debug mode:

Lastly, we are injecting the IMapper interface directly on the Controller constructor to use Dependency Injection. So that every request on HomeController will inject a new instance of IMapper until the request is finish.

You can take a look on the simple final solution here on my Github Repository: https://github.com/willydavidjr/AutoFacAndAutoMapperMVC

AWS: Mission To MARS Hackathon!

Willy David Jr — Thu, 06 Aug 2020 18:49:53 +0000

Did you love my post?

Check out this virtual hack from AWS: Mission To M|A|R|S Hackathon there's $65K in prizes and you have six months to learn a new technology and build an app. Pretty cool!

http://bit.ly/AWSMission2MarsHack

Registration opens August 10!

See you in MARS!

How to Publish Files to Github using Visual Studio Code

Willy David Jr — Sat, 01 Aug 2020 20:14:52 +0000

Did you love my post?

Hello coders!

I will be sharing some basic fundamentals on publishing your code files to Github using Visual Studio Code. Normally we do this using Visual Studio but we can also easily do this via Visual Studio Code. So let's start.

First open your Visual Studio and click the Source Control Icon in the left (Ctrl + Shift + G):

This will tell you that you need valid Git Installation. You can get Git on this link: https://git-scm.com/downloads

Afterwards, go to the folder/workspace which contains your files that you want to publish on your Visual Studio Code. Click again Source Control Icon and select Publish to Github:

This time it will launch your browser which will authenticate your request:

Select Continue button and on the next page of the browser, copy the token, switch back to VS Code and click Signing in to github.com in your status bar. Paste the token and hit enter.

Once done, let's start committing and publishing your changes to your Github master branch!

First, try to edit one of your file, and click the Source Control Icon, by now you should be familiar with the Source Control Icon. If not, it looks like this:

Your next task is to stage your changes. Click the plus sign on the files that was changed and you want to commit:

You will notice that your selected files will be moved to Stage Changes category. Type your initial description then click the Check/Commit sign.

Lastly click the three dots and click the Push option to push your changes to your master branch:

Take note that you are pushing here on your master and private branch on Github. To modify your preferred settings and make your Github repository public, you can always go to Github and make your changes on the site. Happy coding!

Microsoft Azure Virtual Training with Free Exam Voucher

Willy David Jr — Thu, 30 Jul 2020 12:27:46 +0000

Did you love my post?

Hello dev community!

I am sharing you this link that was sent to me by Microsoft. Basically I already tried their Azure Virtual 2-Day Training and it was awesome!

In fact, I made a repeat on the week after I took the training. The training is actually until next week only and the good thing is that they extended it until end of August!

So what are you waiting for, take the 2-day Azure Virtual Training in Microsoft and receive also Free Exam Voucher to certify yourself for free!

Here is the link for the registration:

https://info.microsoft.com/AP-AzureINFRA-CATALOG-FY20-07Jul-07-MicrosoftAzureVirtualTrainingDayFundamentals-SRDEM30218_CatalogDisplayPage.html

See screenshot of my voucher that I received:

Happy coding and welcome to cloud! :)

Why Use Events Instead of Delegates in C#?

Willy David Jr — Mon, 27 Jul 2020 18:22:01 +0000

Did you love my post?

Why do we use Events in C# instead of delegates? Is it possible to use with delegates alone? Why add events? Some of the common questions I get particularly to Junior Developers. Today, we will show some of the major reasons why.

I divided the code to Team Developer and Team Client. Team Developer will code the delegate and Team Client will instantiate the class and subscribe to delegate.

Team Developer

First lets say we want to use delegates alone using the following code:

 public delegate void YourLoggingHere();
 public class WhyUseEvents
 {
    public YourLoggingHere MyLogging;
    public void MyMainProgram()
    {
       ExecuteValidation();
    }

    private void ExecuteValidation()
    {
       //Execution of validation and logic here
       //With some business rules etc.

       if (MyLogging != null)
       {
           MyLogging.Invoke();
       }
    }
 }

As you can see, Team Developer declare a "YourLoggingHere" delegate, and declare it as property named "MyLogging". Now Team Client can instantiate this class and use this property and add methods to it.

Team Client

On the following example, Team Client wants to use the class and add methods to "MyLogging" delegate. They can add as many methods as they want. On this case, they only added one:

  WhyUseEvents why = new WhyUseEvents();
  why.MyLogging += () =>
  {
    Console.WriteLine("Hi I am subscribing to the delegate.");
  };

Now both Team Developer and Team Client can use the code properly. But there is a catch. Team Client can directly invoke the delegate!

Issues

  WhyUseEvents why = new WhyUseEvents();
  why.MyLogging += () =>
  {
    Console.WriteLine("Hi I am subscribing to the delegate.");
  };

  why.MyLogging.Invoke();  //Team Client here can directly invoke the delegate!

As you can see on the above code, Team Client can directly invoke the delegate without Team Developer knowing it. It's not a good way to encapsulate your methods and properties since there are other validations to be executed first before invoking the delegate!

Review the Code

Let's review the code, before you can invoke "MyLogging" delegate, there are validation and business logic first before you can finally invoke the delegate.

  private void ExecuteValidation()
  {
       //Execution of validation and logic here
       //With some business rules etc.

       if (MyLogging != null)
       {
           MyLogging.Invoke();
       }
  }

Solution? Yes, Events!

Team Developer solved the problem by adding the event keyword:


//public YourLoggingHere MyLogging;
public event YourLoggingHere MyLogging;

Team Client cannot directly invoke the delegate. If they do, it will trigger an error as shown below:


why.MyLogging.Invoke();

//The event 'WhyUseEvents.MyLogging' can only appear on the left hand side of += or -= (except when used from within the type 'WhyUseEvents')

This is a simplified explanation on why we use events even though we can already use delegates:

To provide encapsulation and not exposing business logic
To prevent Team Client from clearing all assign methods to delegates (You cannot do that for events):

why.MyLogging = null;

And of course to prevent invocation of the delegates.

Cheers I hope you learn on my post and happy coding!

How to Add Project on Azure Devops using Visual Studio 2019

Willy David Jr — Wed, 06 May 2020 01:41:21 +0000

Did you love my post?

Formerly known as Visual Studio Team Services, Azure Devop is a cloud-based version control which offers developers solutions to collaborate on code and track changes visually with unlimited free private Git/TFVC repos on which you the selection to choose either Git or Team Foundation Version Control (TFVC).

So in order to add your projects or solution in Azure DevOps first, go to https://dev.azure.com/ which will redirect you to Azure Devops main site then signup for your account.

Connecting on Azure Repositories.

After login, in order to create and add your repository project, you need to create New Organization first. An organization is like a group of projects or a collection of your related projects.

Organization:

Afterwards, you can now add new repository by clicking New Project.

New Project:

Once you clicked New Project, a dialog will appear on the right side, fill up the necessary fields, and Choose the Version Control to Team Foundation Version Control as highlighted on image.

Linking your local project in Azure Repository Online

Now go to your solution on your machine by opening it on your Visual Studio IDE. In my case, I am using Visual Studio 2019, but this should work the same way on Visual Studio 2015 and 2017 as I have the same IDEs as well.

Go to View -> Team Explorer, then select Manage Connections. You can click either of the options I circled in Red, both will result in a dialog options to Connect to a Project.

Sign-in to your existing account that you used to signup on Dev Azure. Once login, it will automatically populate your related repo that you created awhile ago. On my side, I am connecting to Hello MVC Core repo.

Once you select your repo and click the Connect button, go back to your Solution Explorer, right click your Solution and select Add Solution to Source Control. Select the name of the Azure Repo project you have added online. Type a name for the solution folder then select Ok.

Wait for few seconds, until you see a plus sign on files on your Solution Explorer. You will notice that your files will have a plus sign before its filename.

Afterwards, right click again on your solution on Solution Explorer, then select Check-In...

You're almost done. Compose a descriptive message for your checkin, then your done. Your solution on your local machine is now linked to a version control online!