Tuesday, March 5, 2024

What is Interface

 Definition:

"An interface in object-oriented programming is a collection of abstract methods. It defines a contract for classes that implement it, specifying the methods that must be present in those classes. Unlike classes, an interface doesn't provide any implementation for the methods; it only declares their signatures. Classes that implement an interface must provide concrete implementations for all the methods declared in the interface."

Key Points:

  1. Abstract Methods:

    • "Interfaces consist of abstract methods, which are methods without a body. These methods serve as a blueprint for any class that implements the interface."
  2. Contract:

    • "An interface establishes a contract between the interface and the implementing classes. It specifies what methods the implementing classes must have, but it doesn't dictate how these methods should be implemented."
  3. Multiple Inheritance:

    • "One significant advantage of interfaces is that a class can implement multiple interfaces. This supports a form of multiple inheritance, allowing a class to inherit the method signatures from multiple sources."
  4. Example:

    • "For instance, consider an interface Drawable with a method draw(). Any class that implements this interface must provide its own implementation of the draw() method. This ensures a consistent way of drawing for various objects."

Use in Programming:

  • "Interfaces are used to achieve abstraction and ensure code consistency in large codebases."
  • "They are crucial in scenarios where multiple classes need to share a common set of methods without having a common base class."

When to Use Interfaces:

  • "Use interfaces when you want to define a contract that multiple classes can adhere to without specifying the implementation details."
  • "Interfaces are beneficial in scenarios where you want to achieve loose coupling between components in your system."

What is MVC

 Definition:

"MVC stands for Model-View-Controller, which is a design pattern widely used in software development to organize and structure code in a way that enhances modularity, maintainability, and scalability."

Breakdown of Components:

  1. Model:

    • "The Model represents the application's data and business logic. It encapsulates the data-related operations and responds to requests for information from the View or updates from the Controller."
  2. View:

    • "The View is responsible for presenting the data to the user. It displays the information from the Model and gathers user inputs. Views can be graphical user interfaces, web pages, or any other output representation."
  3. Controller:

    • "The Controller acts as an intermediary between the Model and the View. It receives user inputs from the View, processes them by interacting with the Model, and updates the View accordingly. It manages the flow of data between the Model and the View."

Benefits:

  • "MVC promotes the separation of concerns, making the codebase more modular and easier to maintain."
  • "It enhances code reusability and scalability, allowing for easier updates and additions to the application."
  • "Facilitates collaboration among developers, as different team members can focus on specific components without affecting others."

Real-world Example:

  • "For instance, in a web application, the Model could be responsible for handling database interactions, the View for rendering HTML pages, and the Controller for managing user requests and coordinating the interaction between the Model and the View."

Thursday, February 29, 2024

Ups oauth2.0 in c# get rates list || ups api integration c# || c# oauth 2.0 client example

 using Newtonsoft.Json.Linq;

using System;

using System.Collections.Generic;

using System.Linq;

using System.Net.Http;

using System.Text;

using System.Threading.Tasks;


namespace Ups1

{

    public class Program

    {


        static void Main()

        {


            string client_id = "clientid";

            string client_secret = "clientSecret";

        

            string ups_account_number = "AccountNumber"; 


            // ***** SHIPPING SERVICE AVAILABLE OPTIONS *****

            // Domestic

            // 14 = UPS Next Day Air Early

            // 01 = UPS Next Day Air

            // 13 = UPS Next Day Air Saver

            // 59 = UPS 2nd Day Air A.M.

            // 02 = UPS 2nd Day Air

            // 12 = UPS 3 Day Select

            // 03 = UPS Ground

            // International

            // 11 = UPS Standard

            // 07 = UPS Worldwide Express

            // 54 = UPS Worldwide Express Plus

            // 08 = UPS Worldwide Expedited

            // 65 = UPS Worldwide Saver

            // 96 = UPS Worldwide Express Freight

            // 82 = UPS Today Standard

            // 83 = UPS Today Dedicated Courier

            // 84 = UPS Today Intercity

            // 85 = UPS Today Express

            // 86 = UPS Today Express Saver

            // 70 = UPS Access Point Economy


            // ***** PACKAGE TYPE AVAILABLE OPTIONS *****

            // 01 = Bag, 

            // 02 = Box, 

            // 03 = Carton/Piece, 

            // 04 = Crate, 

            // 05 = Drum, 

            // 06 = Pallet/Skid, 

            // 07 = Roll, 

            // 08 = Tube, 


            // PACKAGE


            // var packages = new List<Package>();

           // packages.Add(new Package(0M, 0M, 0M, 60, 0M));


            var package_info = new

            {

                service = "59",

                package_type = "02",

                Weight = "10",

                length = "7",

                width = "4",

                height = "2",

            };


            // SHIPPER

            var shipper_info = new

            {

                account_number = ups_account_number,

                name = "fromaddressname",

                address1 = "addr1",

                address2 = "addr2",

                address3 = "",

                city = "city",

                state = "state",

                zip = "zipcode",

                country = "us",

            };


            // FROM ADDRESS

            var from_address_info = new

            {

                name = "fromaddressname",

                address1 = "addr1",

                address2 = "addr2",

                address3 = "",

                city = "city",

                state = "state",

                zip = "zipcode",

                country = "US",

            };


            // TO ADDRESS

            var to_address_info = new

            {

                name = "Thomas Jefferson",

                address1 = "931 Thomas Jefferson Parkway",

                address2 = "",

                address3 = "",

                city = "Charlottesville",

                state = "CO",

                zip = "80125",

                country = "US",

            };


            // Get Token

            var accessToken = GetToken(client_id, client_secret);

             // Use API to get price

            var totalCharges = GetShippingCost(accessToken, shipper_info, to_address_info, from_address_info, package_info);


            // Show Price

            Console.WriteLine("Total Charges: $" + totalCharges);

        }


        //static string GetToken(string client_id, string client_secret)

        //{

        //    var combineUserAndPassword = client_id + ":" + client_secret;

        //    var payload = "grant_type=client_credentials";

        //    var authorizationHeader = "Basic " + Convert.ToBase64String(Encoding.UTF8.GetBytes(combineUserAndPassword));


        //    using (var client = new HttpClient())

        //    {

        //        //client.DefaultRequestHeaders.Add("Content-Type", "application/json");

        //        client.DefaultRequestHeaders.Add("x-merchant-id", "string");

        //        client.DefaultRequestHeaders.Add("Authorization", authorizationHeader);


        //        var response = client.PostAsync("https://wwwcie.ups.com/security/v1/oauth/token", new StringContent(payload, Encoding.UTF8, "application/json")).Result;

        //        var result = response.Content.ReadAsStringAsync().Result;


        //        // Convert the JSON response string to an associative array

        //        var responseArray = JObject.Parse(result);


        //        // Extract the access token

        //        var accessToken = responseArray["access_token"].ToString();

        //        return accessToken;

        //    }

        //}

        static string GetToken(string client_id, string client_secret)

        {

            var combineUserAndPassword = client_id + ":" + client_secret;

            var payload = "grant_type=client_credentials";

            var authorizationHeader = "Basic " + Convert.ToBase64String(Encoding.UTF8.GetBytes(combineUserAndPassword));


            using (var client = new HttpClient())

            {

                client.DefaultRequestHeaders.Add("x-merchant-id", "string");

                client.DefaultRequestHeaders.Add("Authorization", authorizationHeader);


                var content = new StringContent(payload, Encoding.UTF8, "application/x-www-form-urlencoded");

                var response = client.PostAsync("https://wwwcie.ups.com/security/v1/oauth/token", content).Result;

                var result = response.Content.ReadAsStringAsync().Result;


                // Check if the request was successful

                if (!response.IsSuccessStatusCode)

                {

                    // Handle error, log, or throw an exception

                    Console.WriteLine("Token request failed: " + result);

                    return null;

                }


                // Convert the JSON response string to an associative array

                var responseArray = JObject.Parse(result);


                // Explicitly check for null before extracting the access token

                var accessTokenTokenProperty = responseArray["access_token"];

                var accessToken = accessTokenTokenProperty != null ? accessTokenTokenProperty.ToString() : null;


                return accessToken;

            }

        }


        static decimal GetShippingCost(string accessToken, dynamic shipper_info, dynamic to_address_info, dynamic from_address_info, dynamic package_info)

        {

            var version = "v1601";

            var requestOption = "Shop";

            var query = new System.Collections.Generic.Dictionary<string, string>();


            using (var client = new HttpClient())

            {

                var payload = new

                {

                    RateRequest = new

                    {

                        Request = new

                        {

                            TransactionReference = new

                            {

                                CustomerContext = "CustomerContext"//,

                                //TransactionIdentifier = "TransactionIdentifier"

                            }

                        },

                        Shipment = new

                        {

                            Shipper = new

                            {

                                Name = shipper_info.name,

                                ShipperNumber = shipper_info.account_number,

                                Address = new

                                {

                                    AddressLine = new[]

                                {

                                    shipper_info.address1,

                                    shipper_info.address2,

                                    shipper_info.address3

                                },

                                    City = shipper_info.city,

                                    StateProvinceCode = shipper_info.state,

                                    PostalCode = shipper_info.zip,

                                    CountryCode = shipper_info.country

                                }

                            },

                            ShipTo = new

                            {

                                Name = to_address_info.name,

                                Address = new

                                {

                                    AddressLine = new[]

                                {

                                    to_address_info.address1,

                                    to_address_info.address1,

                                    to_address_info.address1

                                },

                                    City = to_address_info.city,

                                    StateProvinceCode = to_address_info.state,

                                    PostalCode = to_address_info.zip,

                                    CountryCode = to_address_info.country

                                }

                            },

                            ShipFrom = new

                            {

                                Name = from_address_info.name,

                                Address = new

                                {

                                    AddressLine = new[]

                                {

                                    from_address_info.address1,

                                    from_address_info.address2,

                                    from_address_info.address3

                                },

                                    City = from_address_info.city,

                                    StateProvinceCode = from_address_info.state,

                                    PostalCode = from_address_info.zip,

                                    CountryCode = from_address_info.country

                                }

                            },

                            PaymentDetails = new

                            {

                                ShipmentCharge = new

                                {

                                    Type = "01",

                                    BillShipper = new

                                    {

                                        AccountNumber = shipper_info.account_number

                                    }

                                }

                            },

                            Service = new

                            {

                                Code = package_info.service,

                                Description = "ground"

                            },

                            NumOfPieces = "1",

                            Package = new

                            {

                                PackagingType = new

                                {

                                    Code = package_info.package_type,

                                    Description = "Packaging"

                                },

                                Dimensions = new

                                {

                                    UnitOfMeasurement = new

                                    {

                                        Code = "IN",

                                        Description = "Inches"

                                    },

                                    Length = package_info.length,

                                    Width = package_info.width,

                                    Height = package_info.height

                                },

                                PackageWeight = new

                                {

                                    UnitOfMeasurement = new

                                    {

                                        Code = "LBS",

                                        Description = "Pounds"

                                    },

                                    Weight = package_info.Weight

                                }

                            }

                        }

                    }

                };


                client.DefaultRequestHeaders.Add("Authorization", "Bearer " + accessToken);

                //client.DefaultRequestHeaders.Add("Content-Type", "application/json");

                client.DefaultRequestHeaders.Add("transId", "string");

                client.DefaultRequestHeaders.Add("transactionSrc", "testing");


                var response = client.PostAsync("https://wwwcie.ups.com/api/rating/v1/Rate?{ToQueryString(query)}", new StringContent(Newtonsoft.Json.JsonConvert.SerializeObject(payload), Encoding.UTF8, "application/json")).Result;

                //var response = client.PostAsync("https://wwwcie.ups.com/api/rating/{version}/{requestOption}?{ToQueryString(query)}", new StringContent(Newtonsoft.Json.JsonConvert.SerializeObject(payload), Encoding.UTF8, "application/json")).Result;

                var result = response.Content.ReadAsStringAsync().Result;


                // Convert the JSON response string to an associative array

                var responseArray = JObject.Parse(result);


                // Extract the total charges

                var totalCharges = Convert.ToDecimal(responseArray["RateResponse"]["RatedShipment"]["TotalCharges"]["MonetaryValue"]);

                return totalCharges;

            }

        }


        static string ToQueryString(System.Collections.Generic.Dictionary<string, string> query)

        {

            var array = query.Select(kvp => "{Uri.EscapeDataString(kvp.Key)}={Uri.EscapeDataString(kvp.Value)}").ToArray();

            return "?" + string.Join("&", array);

        }

    }

}


Note : Change your client id , Account Number and client secret and add the correct  from and to address in the above program

After token expire we will get 

this error First = {"response": {

  "errors": [

    {

      "code": "250002",

      "message": "Invalid Authentication Information."

    }

  ]

}}

Monday, February 19, 2024

boxing and unboxing

In C#, boxing and unboxing are concepts related to converting value types (such as int, char, etc.) to reference types (such as object). Let’s explore both concepts with examples:

  1. Boxing:

    • Boxing is the process of converting a value type to the type object or any interface type implemented by that value type.
    • When the Common Language Runtime (CLR) boxes a value type, it wraps the value inside an object instance and stores it on the managed heap.
    • Here’s an example of boxing:
      int i = 123; // The following line boxes 'i'.
      object o = i;
      
    • In this example, the integer variable i is boxed and assigned to the object variable o.
  2. Unboxing:

    • Unboxing is the process of extracting the value type from an object.
    • It converts the object back to its original value type.
    • Example of unboxing:
      o = 123; // Unboxing: extract the value from 'o' and assign it to 'i'.
      int unboxedValue = (int)o;
      
  3. Practical Example:

    • Let’s create a heterogeneous collection using an ArrayList (a dynamically sized array of objects):
      ArrayList mixedList = new ArrayList();
      mixedList.Add("First Group:"); // Add a string element
      for (int j = 1; j < 5; j++)
      {
          mixedList.Add(j); // Add integers (boxing occurs)
      }
      mixedList.Add("Second Group:");
      for (int j = 5; j < 10; j++)
      {
          mixedList.Add(j);
      }
      
      // Display the elements in the list
      foreach (var item in mixedList)
      {
          Console.WriteLine(item);
      }
      
      // Calculate the sum of squares of the first group of integers
      var sum = 0;
      for (var j = 1; j < 5; j++)
      {
          sum += (int)mixedList[j] * (int)mixedList[j]; // Unboxing
      }
      Console.WriteLine($"Sum: {sum}"); // Output: Sum: 30
      
    • In this example, we box integers when adding them to the ArrayList and unbox them during the sum calculation.

Remember that boxing and unboxing have performance implications, so use them judiciously.

Sunday, February 18, 2024

what is asp.net mvc framework

 The ASP.NET MVC (Model-View-Controller) framework is an architectural and design pattern used for developing web applications. Let’s break down what it entails:

  1. Model: The Model component represents the data-related logic in the application. It handles data retrieval, storage, and manipulation. For instance, it can interact with a database or manage business logic.

  2. View: The View component is responsible for the user interface (UI) logic. It generates the visual representation that users interact with. Views are created based on data provided by the Model, but they communicate with the Controller.

  3. Controller: The Controller acts as an intermediary between the Model and the View. It processes incoming requests, manipulates data using the Model, and instructs the View on how to render the final output. The Controller doesn’t handle data logic directly; instead, it orchestrates the flow.

Here are some key points about ASP.NET MVC:

  • Clean Separation: ASP.NET MVC promotes a clean separation of concerns. By dividing the application into distinct components (Model, View, and Controller), developers can manage complexity more effectively.

  • Scalability and Extensibility: It’s a powerful framework for building scalable and extensible projects. Developers can create robust web applications that are easy to maintain.

  • URL Control: ASP.NET MVC provides control over URLs, making it straightforward to design web application architectures with comprehensible and searchable URLs.

  • Test Driven Development (TDD): The framework supports TDD, allowing developers to write tests for their code and ensure its correctness.

Overall, ASP.NET MVC is widely used in industry-standard web development and is also suitable for designing mobile apps.

Thursday, February 15, 2024

Interface

  1. What Is an Interface in C#?

    • An interface in C# is a fully unimplemented class used for declaring a set of operations or methods that an object must provide.
    • It serves as a pure abstract class, allowing us to define only abstract methods (methods without a body).
    • Interfaces are used to achieve multiple inheritances, which classes cannot achieve directly.
    • They also ensure full abstraction because interface methods cannot have a method body.
    • In C#, an interface is a fundamental concept defining a contract or a set of rules that a class must adhere to.
    • It specifies a list of methods, properties, events, or indexers that a class implementing the interface must provide.
    • Interfaces allow you to define a common set of functionality that multiple classes can share, promoting code reusability and ensuring a consistent structure for related classes.
  2. Differences Between Concrete Class, Abstract Class, and Interface in C#:

    • Concrete Class:
      • Contains only non-abstract methods (methods with a method body).
    • Abstract Class:
      • Contains both non-abstract methods and abstract methods (methods without a method body).
    • Interface:
      • Contains only abstract methods (methods without a method body).
  3. Real-World Example: Library Management System

    • Imagine building a Library Management System where you need to handle different types of library items (books, DVDs, etc.).

    • We can define an interface called ILibraryItem to specify common behavior for all library items:

      interface ILibraryItem
      {
          string Title { get; set; }
          void CheckOut(string borrower);
          void Return();
      }
      
    • Now, let’s implement this interface for specific library items:

      • Book:

        class Book : ILibraryItem
        {
            public string Title { get; set; }
        
            public void CheckOut(string borrower)
            {
                // Logic for checking out a book
            }
        
            public void Return()
            {
                // Logic for returning a book
            }
        }
        
      • DVD:

        class DVD : ILibraryItem
        {
            public string Title { get; set; }
        
            public void CheckOut(string borrower)
            {
                // Logic for checking out a DVD
            }
        
            public void Return()
            {
                // Logic for returning a DVD
            }
        }
        
    • By using the ILibraryItem interface, we ensure that all library items adhere to the same contract, allowing consistent handling across different types of items.

    • Interfaces promote code reusability, maintainability, and a consistent structure for related classes. 

Remember, interfaces provide a powerful way to define contracts and encourage good design practices in your C# code!

Tuesday, February 6, 2024

Introduction to C#

 Certainly! C# (pronounced “C-Sharp”) is a powerful and versatile programming language created by Microsoft. Let’s explore some key points about C#:

  1. What is C#?

    • C# is an object-oriented programming language that runs on the .NET Framework.
    • It has its roots in the C family of languages and shares similarities with C++, Java, and JavaScript.
    • The first version of C# was released in 2002, and the latest version (C# 12) arrived in November 2023.
    • C# is used for a wide range of applications, including:
      • Mobile applications
      • Desktop applications
      • Web applications
      • Web services
      • Games
      • Database applications
      • And much more!
  2. Why Use C#?

    • Popularity: C# is one of the most popular programming languages globally.
    • Ease of Learning: It is easy to learn and has a straightforward syntax.
    • Community Support: C# has a large and active community.
    • Object-Oriented: C# provides a clear structure to programs, allowing code reuse and lowering development costs.
    • Familiarity: If you know C, C++, or Java, transitioning to C# is relatively straightforward.
  3. Getting Started:

    • You don’t need prior programming experience to learn C#.
    • Explore tutorials, videos, and interactive lessons to grasp the basics of C#.
    • Whether you’re building web apps, desktop software, or games, C# offers a robust foundation for your projects.

Happy coding! 🚀 If you’re ready to dive in, you can start learning C# through resources like W3SchoolsMicrosoft’s .NET Learn, or Microsoft Learn’s C# tutorials