Programming in C#: Exam 70-483 (MCSD) Guide

Learn basic to advanced concepts of C#, including C# 8, to pass Microsoft MCSD 70-483 exam

Simaranjit Singh Bhalla, SrinivasMadhav Gorthi

• Publisher: Packt Publishing
• Year: 2019
• ISBN:
  9781789535402
• Edition: 1
• Topic: Computer Science
• Subtopic: Programming in C#
• Index: Computer Science

Acquire necessary skills in preparing for Microsoft certification and enhance your software development career by learning the concepts of C# programming

Key Features

• Prepare for the certification using step-by-step examples, and mock tests with standard solutions
• Understand the concepts of data security for secure programming with C#
• Learn to scale and optimize your application codebase using best practices and patterns

Book Description

Programming in C# is a certification from Microsoft that measures the ability of developers to use the power of C# in decision making and creating business logic. This book is a certification guide that equips you with the skills that you need to crack this exam and promote your problem-solving acumen with C#.

The book has been designed as preparation material for the Microsoft specialization exam in C#. It contains examples spanning the main focus areas of the certification exam, such as debugging and securing applications, and managing an application's code base, among others. This book will be full of scenarios that demand decision-making skills and require a thorough knowledge of C# concepts. You will learn how to develop business logic for your application types in C#. This book is exam-oriented, considering all the patterns for Microsoft certifications and practical solutions to challenges from Microsoft-certified authors.

By the time you've finished this book, you will have had sufficient practice solving real-world application development problems with C# and will be able to carry your newly-learned skills to crack the Microsoft certification exam to level up your career.

What you will learn

• Explore multi-threading and asynchronous programming in C#
• Create event handlers for effective exception handling
• Use LINQ queries for data serialization and deserialization
• Manage filesystems and understand I/O operations
• Test, troubleshoot, and debug your C# programs
• Understand the objectives of Exam 70-483 and apply common solutions

Who this book is for

The book is intended to the aspirants of Microsoft certifications and C# developers wanting to become a Microsoft specialist. The book does not require the knowledge of C#, basic knowledge of software development concepts will be beneficial

Mock Test 1

1. We have a class called LogException. The class implements a CaptureException method using the following code segment: public static void CaptureException(Exception ex). Pick one of the following syntaxes to make sure all exceptions in the class are captured and rethrow the original exception, including the stack:
   1. catch (Exception ex)
      {
      LogException.CaptureException(ex);
      throw;
      }
   2. catch (Exception ex)
      {
      LogException.CaptureException(ex);
      throw ex;
      }
   3. catch
      {
      LogException(new Exception());
      }
   4. catch
      {
      var ex = new Exception();
      throw ex;
      }
2. You are creating a class named Store, which should have a Store Type member that meets the following requirements:
   • The member must be accessible publicly.
   • The member must only acquire a restricted set of values.
   • While setting the value, the member must ensure that it validates the input set in the member.

In which form should you implement the score member?

• 1. public string storeType;
  2. protected String StoreType
     {
     get{}
     set{}
     }
  3. private enum StoreType { Department, Store, Warehouse}
     public StoreType StoreTypeProperty
     {
     get{}
     set{}
     }
  4. private enum StoreType { Department, Store, Warehouse}
     private StoreType StoreTypeProperty
     {
     get{}
     set{}
     }

3. Write an extension method for a string; it should have an IsEmail method . The method should check whether the string is a valid email. Select the syntax and map it to the places where it should be placed:

----------------------/*Line which needs to be filled*/
{
 ------------------/*Line which needs to be filled*/
 {
 Regex regex = new Regex(@"^([\w\.\-]+)@([\w\-]+)((\.(\w){2,3})+)$");
 return regex.IsMatch(str);
 }
}

1. 1. protected static class StringExtensions
   2. public static class StringExtensions
   3. public static bool IsEmail(this String str)
   4. public static bool IsEmail(String str)
   5. public class StringExtensions

4. You need to write an application in which we ensure that the garbage collector does not release an object's resources until the process completes. Which of the following syntaxes would you use?
   1. WaitForFullGCComplete()
   2. RemoveMemoryPressure()
   3. SuppressFinalize()
   4. collect()
5. For a list collection, someone has written the following code:

static void Main(string[] args)
{
 List<string> states = new List<string>()
 {
 "Delhi", "Haryana", "Assam", "Punjab", "Madhya Pradesh"
 };
}

private bool GetMatchingStates(List<string> states, string stateName)
{
 var findState = states.Exists(delegate(
 string stateNameToSearch)
 {
 return states.Equals(stateNameToSearch);
 });
 return findState;
}

Which of the following code segments is the correct representation of the corresponding Lambda expression?

• 1. var findState = states.First(x => x == stateName);
  2. var findState = states.Where(x => x == stateName);
  3. var findState = states.Exists(x => x.Equals(stateName));
  4. var findState = states.Where(x => x.Equals(stateName));

6. Which of the following collection objects would fulfill the following requirements?
   • It must internally store a key and value pair for each item.
   • It must allow us to iterate over the collection in order of the key.
   • It allows us to access the objects using the key.

The collection objects are as follows:

• 1. Dictionary
  2. Stack
  3. List
  4. SortedList

7. You are creating an application that has a Student class. The application must have a Save method that should satisfy the following:
   • It must be strongly typed.
   • The method must only accept types inherited from the Animal class that use a constructor that accepts no parameters.

The options are as follows:

• 1. public static void Save(Student target)
     {
     }
  2. public static void Save<T>(T target) where T : Student , new()
     {
     }
  3. public static void Save<T>(T target) where T : new(), Student
     {
     }
  4. public static void Save<T>(T target) where T : Student
     {
     }

8. We are writing an application that is receives a JSON input from another application in the following format:

{
 "StudentFirstName" : "James",
 "StudentLastName" : "Donohoe",
 "StudentScores" : [45, 80, 68]
}

We have written the following code in our application to process the input. What would be the correct syntax in the ConvertFromJSON method to ensure that we convert the input to its equivalent student format?

public class Student
{ 
 public string StudentFirstName {get; set;}
 public string StudentLastName {get; set;}
 public int[] StudentScores {get; set;}
}

public static Student ConvertFromJSON(string json)
{
 var ser = new JavaScriptSerializer();
 ----------------/*Insert a line here*/
}

The options are as follows:

• 1. Return ser.Desenalize (json, typeof(Student));
  2. Return ser.ConvertToType<Student>(json);
  3. Return ser.Deserialize<Student>(json);
  4. Return ser.ConvertToType (json, typeof (Student));

9. You have an array of integers with studentId values in them. Which code logic would you use to do the following?
   • Only select the unique studentID
   • Remove a particular studentID from the array
   • Sort the result in descending order into another array

Your options are as follows:

• 1. int[] filteredStudentIDs = s...

Table of contents

• Title Page
• Copyright and Credits
• About Packt
• Contributors
• Preface
• Learning the Basics of C#
• Understanding Classes, Structures, and Interfaces
• Understanding Object-Oriented Programming
• Implementing Program Flow
• Creating and Implementing Events and Callbacks
• Managing and Implementing Multithreading
• Implementing Exception Handling
• Creating and Using Types in C#
• Managing the Object Life Cycle
• Find, Execute, and Create Types at Runtime Using Reflection
• Validating Application Input
• Performing Symmetric and Asymmetric Encryption
• Managing Assemblies and Debugging Applications
• Performing I/O Operations
• Using LINQ Queries
• Serialization, Deserialization, and Collections
• Mock Test 1
• Mock Test 2
• Mock Test 3
• Assessments
• Other Books You May Enjoy