DEV Community: Sele

Inheritance

Sele — Sun, 01 Aug 2021 14:16:32 +0000

In the last article we talked about OOP briefly. Just trying to understand the concept and the relationship between an object and a class. If you haven’t read that I advise you to. This is the link to that article here. It will help to grab better what is in this article. So lets us jump into the business of today. We want to look into Inheritance one of the the four pillars of OOP.
Inheritance allows us to create classes that have derived attributes from another existing class. The idea behind inheritance is that a class (child class) can acquire/inherit attributes from another existing class (parent class). This was used as a way for re-using code. Let’s us look at an example. So let us continue from where we stopped in the previous post. we have an existing class called class Person

    public class Person
    {
        public string Name { get; set; }
        public string Job { get; set; }
        public string Height { get; set; }
        public string Weight { get; set; }
        public string Walking()
        {
            return "I am Walking";
        }
        public string Sleeping()
        {
            return "I am sleeping";
        }

    }

Let us create another class called father and consider these code snippets

    public class Father:Person
    {
        public bool IsEmployed { get; set; }
        public string[] KidsNames{ get; set; }

        public string Wife { get; set; }

    }

In the above the syntax of :Person is how inheritance works. What we are saying here is that the father class inherits from the Person class

  class Program
    {
        static void Main(string[] args)
        {
            //create an instance of that class
            Person person = new Person();
            Father father = new Father();
            //instantiate the values in that class
            person.Job = "Banker";
            person.Name = "Jacob";
            person.Height = "5,3";
            person.Weight = "65kg";
            // All these are the inherited attributes from the class person
            father.Height = "5,3";
            father.Name = "Richard";
            father.Weight = "70kg";
            father.Job = "SalesMan";
            //These are the attributes specific to the class father
            father.IsEmployed = true;
            father.Wife = "Sandra";
            father.KidsNames = new string[] { "Ayo", "Prosper", "David" };
            //Display them on the screen
            Console.WriteLine(person.Weight);
            Console.WriteLine(person.Height);
            Console.WriteLine(person.Job);
            Console.WriteLine(person.Name);
            Console.WriteLine(person.Sleeping());
            Console.WriteLine(person.Walking());
            Console.WriteLine(father.Weight);
            Console.WriteLine(father.Height);
            Console.WriteLine(father.Job);
            Console.WriteLine(father.Name);
            Console.WriteLine(father.Wife);
            Console.WriteLine(father.Sleeping());
            Console.WriteLine(father.Walking());

        }

As we can see we created an instance of the father class and this instance has the father class attributes and the Person parent class attribute.
There is more to inheritance like multi-level inheritance where a sub class will act as a parent class for another subclass and multiple inheritance where a class can inherit from multiple parent classes. I try to keep my explanations short and straight-forward. I will like to hear your comments on the article

OOP? START HERE

Sele — Fri, 02 Jul 2021 22:29:32 +0000

Some time or another you must have come across the term object-oriented programming. It is the most popular programming paradigm in software engineering. Object oriented programming is a programming paradigm that is heavily based on the concepts of classes and objects, where these objects can contain data and procedures. It allows us to structure our applications into entities called classes. We can also define OOP as a paradigm that allows us to represent real world entities as object and classes. For some history OOP started in around 1962 with a programming language called SIMULA. It was mainly used for simulations, but it wasn’t until the introduction of c++ that OOP became main stream in software engineering.
OOP is strongly based on the concept on object and classes. So, what are classes and objects. Basically, a class is simply the blueprint that defines the structure of how an instance of an object will be. When we say blue print it consist of data (variables and fields) and procedure(methods) pertaining to that entity. An object therefore is simply the instance of a class which will then take up all the attribute of the class in question. Let’s take a simple example

    public class Person
    {
        public string Name { get; set; }
        public string Job { get; set; }
        public string Height { get; set; }
        public string Weight { get; set; }
        public string Walking()
        {
            return "I am Walking";
        }
        public string Sleeping()
        {
            return "I am sleeping";
        }

}

The source code above is a class called person with some field attributes and methods

static void Main(string[] args)
        {
            //create an instance of that class
            Person person = new Person();
            //instantiate the values in that class
            person.Job = "Banker";
            person.Name = "Jacob";
            person.Height = "5,3";
            person.Weight = "65kg";
            //Display them on the screen
            Console.WriteLine(person.Weight);
            Console.WriteLine(person.Height);
            Console.WriteLine(person.Job);
            Console.WriteLine(person.Name);
            Console.WriteLine(person.Sleeping());
            Console.WriteLine(person.Walking());
        }

We created an instance of the class Person and gave the fields values. The ‘person’ is an object. We can now instantiate those fields with values or run the methods. So from the example we can see that the object 'person' has all the attributes of the class Person. The Person class defined the blueprint and the instance of that class which is 'person' had all the properties of class Person. So that’s is the basic relationship with classes and objects
Today we talked about the basics of OOP (object-oriented programming), but note this is just the start. OOP is a wide concept; in subsequent articles I will explain more like the pillars of OOP and object-oriented design, but for now let us stop here. We created a class and we created an instance of that class. We were able to explain how the class and the object are related. There will be more articles coming from this topic. Please like, comment and follow for more.

Generic Programming

Sele — Wed, 10 Feb 2021 17:53:43 +0000

Generics and generic programming are some of the most powerful techniques that developers use to write clean and reusable code. In this article, we are going to be looking at what generic programming is, how it can be applied and why you should start maximizing its power. Before we get our hands dirty on some code lets us look into some ground concepts.

What is Generic Programming

Generic programming is a style of programming in which the types of the objects or variables can be specified at a later time. It allows developers to write code in such a way where the types are parameters.
Some advantages of generics include:

Code reuse
It prioritizes type safety
It also reduces the need to cast an object to other types

NOTE: Dynamically typed programming languages do not have generics. For example javascript, you can create a function and the parameters will work with any type. So this concept is mostly for strongly typed programming languages like java and c#.

The implementation is going to be in c# but this concept is widely used in a lot of strongly-typed programming languages. So let’s go on.

Let’s consider a response model for API endpoints. It will be used as a structure for how all our API responses should look like.

public class Response<T> 
    {
        public bool Successful { get; set; }

        public string Message { get; set; }

        public  T  Data { get; set; }
        public  IEnumerable<T>  DataList { get; set; }

    }

In the code above the <T> stands for the generic parameter. As you will see we would be able to pass any type of our choice to the class instantiation to determine what the type of the variable Data and DataList will be. So let us use the model on a simple API endpoint.

[HttpGet]
        public IActionResult GetItems()
        {
            var result = item.GetItems();
            return Ok(new Response<Item>
            {
                Successful = true,
                DataList = result,
                Data = null,
                Message = "operation sucessfull"
            });
        }

Inside the ok return statement, we pass the response to the item with the response model we created before and passing a type of item (this is an entity type that was created) into the response object inside the arrow ‘<>’ brackets.

public IActionResult Detail(int? id)
        {
            if (id == null)
            {
                return NotFound();
            }
            var result = ops.GetSub(id);
            return Ok(new Response<subTasks>
            {
                Data = result,
                Message = "Operation Successful",

            });
        }

Now in the code above you see we used the same response model and passed in the type parameter into the arrow brackets “<>”, but of a different type of ‘subtask’. The response model is very reusable.
This is a very simple way of implementing generics in c#. we can do a lot more, lets look into how generics can improve abstractions. In the next example, we would look into what we call a generic repository.
So let us consider this interface.

public interface IRepository<T> where T: class
    {
        Task<int> Count { get; }
        Task<T> Add(T item);
        Task<bool> Remove(T item);
        Task<IQueryable<T>> GetBy(Func<T, bool> predicate);
        Task<T> Update(T entity);
        Task<T> GetById(object id);

   }

And this is the implementation

private DbContext<IdentityUser> _dbContext;
        public Repository(DbContext<IdentityUser> dbContext)
        {
            _dbContext = dbContext;
        }



        public async Task<T> Add(T item)
        {
            await _dbContext.AddAsync<T>(item);
            int count = _dbContext.SaveChanges();
            if (count < 1)
            {
                return null;
            }
            return item;
        }


        public async Task<IQueryable<T>> GetAll()
        {
            var allItem = await Task.Run(() => _dbContext.Set<T>().AsQueryable());
            return allItem;
        }
        public async Task<T> GetById(object id)
        {
            return await _dbContext.Set<T>().FindAsync(id);
        }

        public async Task<bool> Remove(T item)
        {
            _dbContext.Set<T>().Remove(item);
            int count = await _dbContext.SaveChangesAsync();
            if (count < 1) { return false; }
            return true;
        }

        public async Task<T> Update(T entity)
        {
            _dbContext.Entry<T>(entity).State = EntityState.Modified;
            int count = _dbContext.SaveChanges();
            if (count < 1)
            {
                return null;
            }
            return entity;
        }

    }

The <T> in the methods stand as the type parameters.

public class StudentService : IStudentService {
    private readonly IRepository<student> _repo;
    public StudentService (IRepository<student> repo) {
        _repo = repo;
    }
    public async Task<List<student>> GetAll () {
        var result = await _repo.GetAll ();
        return result;
    }
    public async Task<student> GetById (int id) {
        var res = await _repo.GetById (id);
        return res;
    }
    public async Task < (bool success, string message) > Create (student obj) 
    {
        var resVal = await _repo.Add (entity);
        if (resVal.Id > 1) {
            return (true, "Operation Successful");
        }
        return (false, "Operation not Successful")
    }
    public async Task < (bool success, string message) >Update (student obj) 
    {
        var retVal = await _repo.Update(entity);
        if (retVal.Id > 0) {
            return (true, "Operation Successful");
        }
        return (false, "Operation not Successful")
    }  
}

In the code above the generic repository is been used in another service. The IRepository implementation can be used in other services with the implementation that we specified, because of generics we can have cleaner abstractions by using a simple implementation for all types.
The point is that we can make better abstractions and make the code more reusable and type-safe. So that’s it on this topic, I am looking forward to seeing how you guys use this technique even in different languages. Please if there anything you didn’t understand put it in the comments I am listening, Have a nice day thank you.

WHAT IS C# .NET and WHY SHOULD I EVEN USE IT?

Sele — Thu, 21 Jan 2021 09:06:52 +0000

If you have been paying some attention to the popularity of programming languages and tools you will notice a rise in the use of C# and .NET. In recent years there has been a lot of changes and revamp in the .NET ecosystem. A lot of people still attribute .net to a windows-only platform which is not true since the launch of .NET core in 2016. So there are a lot of questions and things to explore such as;
What is .NET?
Why should I use .NET?
If I am already a .NET developer what’s in it for me?
In this article, we would do justice to those questions

What is .NET?
The .NET framework is a software development framework for building and running applications. It is regarded as a development platform made up of tools, programming languages, and libraries for building different types of applications.

Is .NET still exclusive to Windows?
In 2016 Microsoft officially launched .NET core which is cross-platform. .NET developers are now able to write truly cross-platform apps that can run on Windows, Linux, and macOS.
The .NET framework over the years has been able to record some huge success, especially among large scale enterprises.
Let’s look into some of them and why they are preferred choices for many businesses.

Backend Web apps:
Asp.NET core is the backend web framework for developing web APIs using either C# or F#. Asp.NET Core is a high performance and scalable web framework based on the MVC design pattern. Some of its major features are; a robust authentication and authorization framework with asp.NET identity, ORM with entity framework, and an in-built logging system. It also promises easy deployment especially if you are deploying to Azure. Asp has been the choice of enterprise application development for a long time and has spread to other use cases including small to medium size projects like simple restaurant management systems and inventory systems.

Internet Of Things (IoT):
C# has been one of the major players in IoT. C# can be used to develop cross-platform IOT systems and provides support for multiple sensors and input devices. Input devices that use SPI, serial port interfaces GPIO. With C# you can build IoT apps that run on Raspberry Pi, humming Board, Beagle Board, and more. C# in IOT is BIG. If you are looking to go into IoT C# is an amazing choice.

Desktop Apps
With WPF we can develop cross-platform desktop apps in .net using c# and XAML for design. Very Good development experience.

Mobile Apps
The xamarin framework allows c# developers to develop cross-platform mobile apps in IOS and Android. It is loved by everyone from freelance developers to enterprise engineers. Support from top companies like UPS and Alaska Airlines and amazing tools like the Bot framework, Xamarin is loved by all.
Game Development
Many of you will have seen or heard about the unity game engine. It one of the most popular game engines alongside the likes of Unreal. The major programming language of choice in unity is C#. Unity gives you a user-friendly environment to create games on all platforms including mobile with C#

Front-end web apps
Yes, it is possible, there is another option to building web interfaces other than JavaScript. With a new web technology called blazor. With the help of web assembly (which we will talk about in more recent posts) other compiled languages like C++ and Rust can run in the browser. One of the biggest players in this web assembly game is Blazor. Blazor is a front-end C# framework for building interactive web user interfaces. So instead of having HTML, CSS and JavaScript. We can now have HTML, CSS, and Blazor.

The .NET platform is a powerful one and more keeps on coming. A new release of .NET 5 is out and it just screams BETTER! .NET is an amazing platform for software development and every developer should give it a chance.