Forem: Nitish Prajapati

C# Collection Framework

Nitish Prajapati — Mon, 10 Apr 2023 18:37:31 +0000

For many applications, we want to create and manage groups of related objects.
There are two ways to group objects:-

Arrays are most useful for creating and working with a fixed number of strongly typed objects.

Collections provide a more flexible way to work with groups of objects. Unlike arrays, the group of objects you work with can grow and shrink dynamically as the needs of the application change. For some collections, you can assign a key to any object that you put into the collection so that you can quickly retrieve the object by using the key.

A collection is a class, so you must declare an instance of the class before you can add elements to that collection.

Generally there are 3 types of Collections:-

System.Collections.Generic Classes
System.Collections.Concurrent Classes
System.Collections.Classes

Let's start with using a Simple Collection:-
We will be Implementing the generic List class , which enables you to work with a strongly types list of objects.

//Creating a list of strings
var salmons = new List<string>();
salmons.Add("chinook");
salmons.Add("coho");
salmons.Add("pink");
salmons.Add("sockeye");

// Iterate through the list.
foreach(var salmon in salmons)
{
    Console.Write(salmon + " ");
}
//Result: chinook coho pink sockeye

If the contents of a collection are known in advance, you can use a collection initializer to initialize the collection.

// Create a list of strings by using a
// collection initializer.
var salmons = new List<string> { "chinook", "coho", "pink", "sockeye" };

// Iterate through the list.
foreach (var salmon in salmons)
{
    Console.Write(salmon + " ");
}
// Output: chinook coho pink sockeye

You can use a for statement instead of a foreach statement to iterate through a collection. You accomplish this by accessing the collection elements by the index position. The index of the elements starts at 0 and ends at the element count minus 1.

The following example iterates through the elements of a collection by using for instead of foreach.

// Create a list of strings by using a
// collection initializer.
var salmons = new List<string> { "chinook", "coho", "pink", "sockeye" };

for (var index = 0; index < salmons.Count; index++)
{
    Console.Write(salmons[index] + " ");
}
// Output: chinook coho pink sockeye

The following example removes an element from the collection by specifying the object to remove.

// Create a list of strings by using a
// collection initializer.
var salmons = new List<string> { "chinook", "coho", "pink", "sockeye" };

// Remove an element from the list by specifying
// the object.
salmons.Remove("coho");

// Iterate through the list.
foreach (var salmon in salmons)
{
    Console.Write(salmon + " ");
}
// Output: chinook pink sockeye

The following example removes elements from a generic list. Instead of a foreach statement, a for statement that iterates in descending order is used. This is because the RemoveAt method causes elements after a removed element to have a lower index value.

var numbers = new List<int> { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 };

// Remove odd numbers.
for (var index = numbers.Count - 1; index >= 0; index--)
{
    if (numbers[index] % 2 == 1)
    {
        // Remove the element by specifying
        // the zero-based index in the list.
        numbers.RemoveAt(index);
    }
}

// Iterate through the list.
// A lambda expression is placed in the ForEach method
// of the List(T) object.
numbers.ForEach(
    number => Console.Write(number + " "));
// Output: 0 2 4 6 8

For the type of elements in the List, you can also define your own class. In the following example, the Galaxy class that is used by the List is defined in the code.

private static void IterateThroughList()
{
    var theGalaxies = new List<Galaxy>
        {
            new Galaxy() { Name="Tadpole", MegaLightYears=400},
            new Galaxy() { Name="Pinwheel", MegaLightYears=25},
            new Galaxy() { Name="Milky Way", MegaLightYears=0},
            new Galaxy() { Name="Andromeda", MegaLightYears=3}
        };

    foreach (Galaxy theGalaxy in theGalaxies)
    {
        Console.WriteLine(theGalaxy.Name + "  " + theGalaxy.MegaLightYears);
    }

    // Output:
    //  Tadpole  400
    //  Pinwheel  25
    //  Milky Way  0
    //  Andromeda  3
}

public class Galaxy
{
    public string Name { get; set; }
    public int MegaLightYears { get; set; }
}

Further we will discuss more about the different classes in Collection framework.

IIS Server Setup for Beginners/Newbie for .NET

Nitish Prajapati — Mon, 11 Jul 2022 04:52:52 +0000

IIS(Internet Information Services) is Web Based Server used for Hosting the Web Sites.
IIS simply uses the .NET Framework 4.8(which is latest) and hosting bundle for Hosting the Web Sites and .NET Core for Hosting application build in .NET Core.
Link to Framework is in below:-

https://docs.microsoft.com/en-us/aspnet/core/host-and-deploy/iis/hosting-bundle?view=aspnetcore-7.0

However in General Web Server is just similar to your local computer.

IIS and Application Pool:-

**
Generally a local machine in case need a user to run the System , In your case you are using your own local machine so you yourself becomes the User.
But in case of the IIS Server we have Application Pool who which run/operate in our absence the whole server depends on Application Pool

Sites:-

If you want to configure for your website all we need to do is to configure Physical Path of the website(As you know IIS server itself is the Computer).
Keep all your Code(Build) and Script in a specific Path in any Drive , Ensure that we Application and IIS Application has the permission to Read, Write and Modify (Incase if you want to store any file on IIS Server will allow the same through Application Pool)
Then you have to bind you website incase of Http and Https we have specified ports in the IIS.

Some more configuration are required but this is the Basic requirement from where you can start your configuration for Hosting your own website on local.

API Integration: Request and Response

Nitish Prajapati — Fri, 11 Sep 2020 06:35:29 +0000

WHAT IS API?

API Stands for Application Programming Interface.API enables interaction with Data, Application, and Services. API delivers data between devices and programs. Using API we access the Data in Request and Response format. That's all for API now let's talk about the working

WORKING OF API's

API Integration needs to be Done for the working of APIs.

STEP'S:-
First of all the Response from APIs are in JSON(Javascript Object Notation) format and the Same format is used for Request.
In the Application, the Request Headers and Request Body are Constructed for Accessing the Details Device from Where the Request is Send. So at the End Point, the Server knows from where the Request is Generated.

Request Body in C#:-
  namespace Request_Body
{
  public class Request_class_name
  {
   //Details
  }
  public class Main_Request_Body
  {
   //Details
  } 
  public class Request_Body
  {
   //Details
   //Request Body
   //Request Header
  } 
  public class Request_Root
  {
   //Details
  }

}

That is the Request Body for Sending Request to API

This API Request with the Help of Request Header and Request Body is Send to ESB(Enterprise Service Bus) Path where the Response is Generated where the Endpoint is Hit and Response is Send Back to Device

The request is Converted into JSON format from Object Format this is an Important Step which needs to be Done Carefully.

After getting a response from ESB we Need to store in Response Body

Response Body in C#:-
  namespace Response_Body
{
  public class Response_class_name
  {
   //Details
  }
  public class Main_Response_class_name
  {
   //Details
  } 
  public class Response_Body
  {
   //Details
   //Response Body
   //Response Header
   //Status 
  } 
  public class Response_Root
  {
   //Details
  }

}

Here Status Shows whether the Request is Valid or What is Output of the Request and Accordingly, we need to need to Display the Output of the Status.

So with Help of Request Body and Response Body APIs Integration can be done.

Postman is a great tool we can use for Checking if the APIs are Hitting the server Properly or Not.

That's all we Generally use for API Integration.

Things an Intern Should Keep In Mind - Tips for Interns

Nitish Prajapati — Thu, 10 Sep 2020 10:16:56 +0000

Goals

Student Starting Internship should be well aware of Technology in which He/She is Working.Awareness brings Clarity to work

Skills

Skills are most important for which he/she gains after an Internship. Skills are Money in Treasure which we use for Getting Job Done. Skills need to utilize at the Right Time and Right Place.

Be punctual

Arrive on time, meet deadlines, and never be in a hurry to leave the office early. Punctuality will speak for your sincerity. Treat your short-term project as a fulltime job to build rapport.

Take initiative

Seek more work. Approach your manager and tell him about the areas you want to work in. Pitch new ideas even without being asked and offer to help where you see a problem. Initiatives from interns are seen as a sign of confidence and eagerness.

Interns should not get confused about there Interest in Technologies whether He/She wants to become Web Developer, Web Designer, Android Developer, iOS Developer, System Administrator.
Interns should Read Out Articles Regarding specific Technology which helps them to Develop their Interest in the specific Area.

Start to .Net Technologies

Nitish Prajapati — Thu, 10 Sep 2020 09:43:30 +0000

Microsoft .Net Framework has been truly Better for Web Development.
.Net Framework Includes LINQ,ASP.NET, ADO.NET, CLR(Common Language Runtime).
C#:-
C# is a general-purpose, multi-paradigm programming language encompassing strong typing, lexically scoped, imperative, declarative, functional, generic, object-oriented (class-based), and component-oriented programming disciplines.
Pros and Cons of C#:-

Easier to learn than c++
Easier to read code than c++
More rapid and potentially less error-prone development than c++ or java (you have unsigned types, you have ref/out, you can make your own value types, you have other useful things that java omits which means you have less jumping through hoops, which means less unnecessary code complexity).
All things are passed by reference except for value types, by default
Garbage collector cleaning up objects once they're no longer used, so you don't have to manually track everything yourself The program is compiled to native binaries optimized for the platform when it is run (and yet it ran slightly slower than c++ code).
Easy to make multiple threads Have a variety of means of suspending threads to wait for signals and such lock(someObject) { code }, which is kind of like java's synchronized but can be used anywhere and requires an object. P/Invoke is much easier to use than JNI - but we probably wouldn't use it since we want to be cross-platform Has an excellent free IDE (visual c# express) - but on windows only (see cons).
You can make value types, which are by default pass by value instead of pass by reference, by making a struct instead of a class.
You have 'ref' and 'out' keywords which allow you to pass a reference to a parameter to a function, without meaning that the parameter must be assigned by the function before it returns. Essentially, ref/out allows the function to modify the variable being passed as the parameter, like passing a reference in c++. Fairly cross-platform with mono, and/but mono is still improving Has unsigned integers (so does c++, java doesn't) If the program crashes, it pops up a dialog telling the user wherein the code and why (on windows) or writes a stack trace to the console (with mono if run with --debug). Programs are compiled to .exe files, and don't need to be recompiled for other OSes - mono can directly run .NET exes. Cons:

Uses more memory than c++

Garbage collector using CPU cycles and memory - (but barely any, at least CPU time) Some things don't work in mono - calling functions in some windows dlls which won't exist on Linux, mono implementation of windows forms need workarounds in code (but we probably won't use them) Mono isn't perfect yet
Have to use .net 2.0 for generics (among other things), 1.1. doesn't have them. Can't use anything newer than 2.0 because 3.0 and up drop support for Windows 98, ME, and maybe 2000. Can't declare functions synchronized
No good IDE on non-windows. Eclipse has a c# plugin but it might not support most of Eclipse's features.
No pointers, but they're replaced by the ref and out parameters, so they're not needed much
Calling methods via delegates are significantly slower than normal method calling (or function pointers in c++, presumably) Requires the (correct version of the) .NET framework to be installed to run the program, which is several hour downloads on dialup.

This is some Terms we should keep in Mind Before Starting for .NET Technology.