DEV Community: Cory Harkins

Cory’s Coding Tips

Cory Harkins — Sun, 15 Oct 2023 01:31:27 +0000

Checking if an element has scrolled into view.

I’ll keep this short and sweet because it took me a while to get this just right.

Here’s the snippet

let hasScrolledIntoView = (element) => {
  const rect = element.getBoundingClientRect();
  return (rect.top < window.innerHeight && rect.bottom >= 0;
}

What’s going on here?
We have a function that takes in an html element.
We get the bounding rectangle.
We return if the top position of the element is < the window’s inner height and the bottom position of the element is ≥ 0.

What do I do with this?
Slap this function inside one of these on scroll babies:

addEventListener("scroll", (event) => {
  hasScrolledIntoView(el);
});

Make sure your el variable is a thing.

And you’re good to go!

See ya next time!

Why do I want to use this?
I didn’t want to find a library to tell me this info and I didn’t want to do offset math.

I originally posted this on medium, you can follow me there:
https://medium.com/p/8f92dcbd6b05

Working with Collections in C# and Asp.net: A Comprehensive Guide

Cory Harkins — Sun, 16 Jul 2023 18:42:49 +0000

In this quick article we will learn how to effectively work with collections in C# and Asp.net.

By the end of this guide you will discover the power of collection classes in C# and Asp.net. Enhance your programming skills and optimize your code with these versatile tools.

With this knowledge you can take your Asp.net development to the next level with comprehensive insights into working with collection classes. Improve performance and efficiency.

Introduction to Collections
Collections play a vital role in C# and Asp.net programming by providing a way to store and manipulate groups of related data. Whether you need to manage a list of items, perform array operations, or maintain key-value pairs, understanding collections is essential. In this blog post, we will explore various collection classes and learn how to effectively work with them.

Arrays in C#
Arrays are a fundamental collection type in C#. They allow you to store multiple elements of the same type in a contiguous block of memory. To use arrays in C#, follow these steps:

Declare an array with the desired type and size.
Initialize the array with values if needed.
Access individual elements using their index.
Perform array operations like sorting, searching, or resizing.
List Class in C#
The List class in C# provides a dynamic array-like structure that allows for efficient insertion, deletion, and modification of elements. To utilize the List class, follow these steps:

Create a new List object by specifying the type parameter.
Add elements using the Add() method.
Access and modify elements using their index.
Utilize various methods like Remove(), Contains(), and Sort() for manipulation.
Benefit from the flexibility and performance of List in a wide range of scenarios.
Dictionary Class in C#
The Dictionary class in C# enables efficient storage and retrieval of key-value pairs. To work with dictionaries in C#, follow these steps:

Declare a new Dictionary object with the desired key and value types.
Add key-value pairs using the Add() method.
Access values using their corresponding keys.
Update or remove entries using appropriate methods.
Leverage the dictionary’s fast lookup capabilities for efficient data retrieval.
Collection Classes in Asp.net
Asp.net provides a set of collection classes that are specifically designed for web development. These classes include:

ViewState: Stores state information that is associated with a specific page.
Session: Maintains state information across multiple requests for a particular user.
Cache: Caches data for efficient retrieval in subsequent requests.
Application: Manages application-level data accessible across users and sessions.
Iterating through Collections
To process the elements of a collection in C#, you can use different techniques like loops or iterator methods. Follow these steps to iterate through a collection:

Determine the appropriate iteration method based on the collection type.
Use a loop (for, foreach) or iterator method (GetEnumerator()) to traverse the collection.
Perform desired operations on each element during iteration.
Handle any exceptions or edge cases that may arise.
Conclusion
Working with collections in C# and Asp.net is essential for efficient and organized programming. By understanding different collection classes, such as arrays, List, and Dictionary, developers can effectively manage data, improve code performance, and create robust applications. Remember to consider the specific requirements of your project when choosing the appropriate collection class. Explore further resources to deepen your knowledge and enhance your skills in working with collections.

This structured blog post provides a comprehensive guide to working with collections in C# and Asp.net. It covers the concept of collections, array manipulation, List usage, Dictionary implementation, Asp.net collection classes, iterating through collections, and more. Apply the outlined steps to make the most of collections in your C# and Asp.net development journey.

Are you using the correct rest attributes?

Cory Harkins — Fri, 23 Jun 2023 18:43:55 +0000

Hello 👋,

Way back when in my early days of being a programmer, when working in full framework MVC, controller endpoints were just a means to an end.

All the things were handled in house by our own systems so it wasn't necessarily crucial to provide the most accurate endpoints, just so long as the job got done we were all happy.

That being said, everything was a [HttpGet] or an [HttpPost].

Needed data? Use a get.
Creating data? Use a post.
Updating? Post.
Delete? Post.

You get the picture. Gets and Posts everywhere all day long.

But as I progressed in my career and curiosity I began to use other controller attributes such as Put and Delete.

Not only did these help, at a glance, to see which method did what in spite of, good or bad, naming conventions; it also made consumption of these endpoints more understandable to front end engineers and external third parties.

The added benefit of using these attributes is that no other targeted rest request type will be allowed to hit that endpoint.

That being said I think it's crucial to know these rest request attributes.

Http Get

Attribute Usage: [HttpGet]
When To Use: When retrieving a collection of data, or a single item of data from some type of storage.

Http Post

Attribute Usage: [HttpPost]
When To Use: When creating a new item to be added to a stored data location.

Http Patch

Attribute Usage: [HttpPatch]
When To Use: When you want to override or update parts of some existing data or object.

Http Put

Attribute Usage: [HttpPut]
When To Use: When you want to completely override or change an entire piece of data or object.

Http Delete

Attribute Usage: [HttpDelete]
When To Use: When you want to delete an object.

These may seem straight forward, but for me, Put vs Patch has always been one that I need to look up from time to time as they're used less often.

I see misuse of these attributes (the biggest offender being Post to do all udpates, deletes, and creates.

And no, the world won't collapse if you use Get and Post over the other options but; we should all strive to build better together and in the evermore connected world, we must make our intentions as clear as we can with our tools.

Thanks everyone!

I Did My Own Small Benchmark. C# - List of Int vs Array of Int

Cory Harkins — Sun, 07 Mar 2021 00:21:41 +0000

I consider myself an easy going guy. I like coffee, the simple things in life. Lists in my programming.

But after doing some reading and reading some debates online, I decided to run a small benchmark myself on Lists vs Arrays.

I did this with an extremely small set of data. I started the C# Stopwatch class and ran the clock over setting up the data structure, populating it, and then looping through those items in it.

Both sets of data held integers 1 through 10.

It took 00:00:00.0230056 seconds to process the list.
It took 00:00:00.0008005 seconds to process the array.

That is a ridiculously smaller amount of time to process the array.

CRAZY.

I wrote more on medium if you want to follow the article there.

Thanks!

My Medium Account

LeetCode with C# - Reverse A String

Cory Harkins — Thu, 14 Jan 2021 00:14:08 +0000

Welcome to my series on LeetCode and solving problems with C#. The goal of this series is to help those who are trying to solve LeetCode problems without directly giving them a copy paste answer.

If you like this article, consider following me over at Medium. The article is available on a paid plan there, but gets released earlier than on dev.to.

You can check that out here: https://coryharkins.medium.com/leetcode-with-c-reverse-a-string-8ebb2f54f88a

To help you direct your brain on how to think about the given problem.

With that let’s get into it. Today’s problem is Reversing a string.
If you just want the solution and skip all the fun, just scroll down to the bottom.

Problem

Write a function that reverses a string. The input string is given as an array of characters char[].

Do not allocate extra space for another array, you must do this by modifying the input array in-place with O(1) extra memory.

You may assume all the characters consist of printable ascii characters.

What does this mean?

We are given an array of characters called s. It is of type char array. We need to reverse this array without allocating additional arrays to hold the data. We need to preform operations on this array and this array alone. The big O notation says that we should solve this with a constant linear time complexity.

If you’d like additional resources on how to solve this problem you can look here.

Linq Solution

public class Solution {
    public void ReverseString(char[] s) {
        Array.Reverse( s );
    }
}

Thoughts on the Linq Solution

Linq provided a very simple and readable way to solve this. You can simply call the Reverse method on your array. Under the hood this is doing something interesting though. From my research the Linq version is allocating a new array and iterating over the source and returning the new array. So this method is cheating; but LeetCode accepts it.

Iterative Solution (Two Pointer Technique)

public void ReverseString(char[] s) 
    {
       int b = 0;
       int e = s.Length - 1;
       char t;
       while (b <= e)
       {
         t = s[b];
         s[b] = s[e];
         s[e] = t;
         b++;
         e--;
       }        
    }

Thoughts on the Two Pointer Technique

The basics of what is going on here is that we have two pointers in the array. One at the beginning (b = 0) and one at the end (e = s.Length -1). We then loop through the array while our starting pointer does not equal our ending pointer.
During this loop we set a variable for our current looking at location to the start of the array (t = s[b];). We then set the first element in the array = to the last, the last equal to the first. Increment our starting index. Decrement our ending index. Then swap it all again until we meet in the middle and break the while loop.

Why does one solution matter over the other?

In short performance. As you can see here in both solutions the Linq solve and the two pointer technique allocate the same amount of memory but the two pointer technique is 60ms faster.

60ms isn’t much to really worry about in an application where timing is not critical.
Here over a longer set of data you can see the performance gains are different as well. Using 60 characters in an array we get the following results in processing time, roughly:
Linq: 420ms.
Two Pointer: 308ms.

Downloading Image Data using ASP.Net

Cory Harkins — Wed, 11 Nov 2020 19:01:10 +0000

This article was originally written on my medium account if you'd like to support me and get these articles first, please consider following me over there for the latest articles, tips, tricks, and more!

source

Hello and welcome back to another tip for my ASP.NET programmers!

So I’ve noticed in my career where data importing is an extremely important and valuable skill to possess as a programmer. Knowledge is power after all! With that power comes the responsibility of downloading and processing images.

Now if you’re not familiar with this (as I was when I first started) or have forgotten how to do this with dot net. Then a quick stack overflow search will land you on a solution similar to this one.

We have a string that holds our image URL.

We have a WebClient object that acts as our web browser.

We have a byte array to hold our retrieved image data.

string imageUrl = "https://placehold.it/300/450";
WebClient client = new WebClient();
byte[] imageBytes = client.DownloadData(imageUrl);

This is all well and fine for a sample of “How to do it” but this doesn’t really cover a lot of ground or use cases. Simply copying and pasting this into your codebase really isn’t enough.

It may work for a while, but as you send more URLs through this code you’ll start to notice its drawbacks and lack of robust data handling abilities.

First of all with this code as it sits we have to remember to dispose of the web client. We can remedy that by wrapping this code in a pattern based using-declaration. This is doable on anything that implements the IDisposable interface.

using(WebClient client = new WebClient())
{
    string imageUrl = "https://placehold.it/300/450";
    byte[] imageBytes = client.DownloadData(imageUrl);
}

This is much better because now the client will dispose of itself when the client is done and out of scope (ie. no longer needed).

But this still doesn’t solve all our problems with this little block of code.

Some resources will block a direct request like this. Typically in the form of a 503 error. You could try and catch this error and either keep trying to process other images, allow the code to keep going if you’re not worried about getting that image, or you can add a few extra lines of code to make this work.

First off, you can set your web client to have a TLS12 protocol passed over on the request. This alone solved about 85% of my 503 errors when retrieving image data.

using(WebClient client = new WebClient())
{
    ServicePointManager.SecurityProtocol = SecurityProtocolType.Tls12;
    string imageUrl = "https://placehold.it/300/450";
    byte[] imageBytes = client.DownloadData(imageUrl);
}

To have this work as written you’ll have to add a using statement at the top of your cs file. This protocol is provided with .Net out of the box.

using System.Net;

Try this to solve your 503 errors when trying to access images.
Some servers are even more guarded against downloading images, but you can still circumvent this by passing in a user-agent string in the header.
To add a user-agent header to this request you simply do the following:

using(WebClient client = new WebClient())
{
    ServicePointManager.SecurityProtocol = SecurityProtocolType.Tls12;
    client.Headers.Add("user-agent", "user agent string");
    string imageUrl = "https://placehold.it/300/450";
    byte[] imageBytes = client.DownloadData(imageUrl);
}

Once this was added, weeks later, and hundreds of image sources parsed and downloaded, I’ve yet to have an issue downloading image data.

So tell me, what are your solves for downloading image data? Did any of these suggestions help you?

Good luck and keep programming!
-Cory

How to build a toastr.js notification system using ASP.NET MVC

Cory Harkins — Tue, 27 Oct 2020 19:39:16 +0000

SRC: https://coryharkins.medium.com/how-to-implement-a-toastr-js-notifications-system-in-asp-net-mvc-5-d755a387ac5b

Hello and welcome!

Today we are going to learn how to implement a server side generated notification system using the following:

MVC 5
C#
ASP.NET
Toastr.js

Setup
To get this set up you can do a couple different things. jQuery is a requirement for this set up but a default MVC project comes with that out of the box so I won’t go over how to set that up here.
First you’ll need to add a reference to toastr.js. You can do so by installing the nuget package for toastr or by clicking here and using the cnd versions. I went with the nuget install and added the references where they were needed.

Your bundle config should look something like this with a reference to toastr:
bundles.Add(new ScriptBundle("~/bundles/toastr").Include( "~/Scripts/toastr.js")); bundles.Add(new StyleBundle("~/Content/css").Include( "~/Content/toastr.css"));

Then add the render call for your script and css files in your layout page (or where ever you need this script to be firing):

@Styles.Render("~/Content/css") //body code and other stuff pertaining to layout @Scripts.Render("~/bundles/toastr")

The Fun Stuff
Ok so now that the boring setup stuff is out of the way. Let’s get down to business.

I first created a new folder for this helper to live in. I called it “Helpers” ( I know, clever). Inside that I made a class called NotificationsHelper.cs.

This class is a view method calls and a model. We will utilize ASP.NET session variables to gather up a list of notifications to process as your code runs then process and render them in the layout with another method call.

Ideally only one or two notifications at most would be toasted to the user but you can go crazy and get a list of 10+ if you want to drive your users mad!

Alright, back to business. Here is the class I’ve set up.

I’ll link the source here.
We can analyze the workflow of things below.

Render Notifications
The render notifications method does exactly that. You call this on your layout page, and any time the layout page is rendered this system will auto populate any toasts that need to send.
It pulls the data from a Session variable that I’ve chosen to call “Notifications” that takes in a List of type Notification that were collected during any Controller calls. It serializes this list to json and stores that in the session.
If there is anything to render is generates basic toastr.js code to pop up an error or success message.

Clear
The clear method just empties the session object once it’s been processes by RenderNotifications();

Add Notification
The add notification method takes in a Notification object that consists of a string message, a string title, and an enum notification type.

This method can be called in any controller and it will store the notification in the session object. Which is then serialized and stored.

Definitions
Notification type. This is an enum that lists out four notification types that we have access to for toastr.js.

Notification. This is a class that holds our properties that we can modify for a notification.

Back to the layout page
Adding this snippet to your _Layout.cshtml page will handle the rendering of any pending notifications. I added mine at the very bottom.
@Html.Raw(NotificationsHelper.RenderNotifications())
Expanding this example
Toastr.js can take in a variety of information for a notification. Use this example as a base and continue onward with their sample docs here (Toastr.js).

Try building some custom html notifications, storing and rendering that using this guide as a base.