Applications: An Atypical Design Beyond 3rd Edition (Early Access) Carl-Hugo Marcotte

Architecting ASP.
NET Core
Applications: An atypical design
patterns guide for .NET 8, C# 12, and
beyond 3rd Edition (Early Access)
Carl-Hugo Marcotte
Visit to download the full and correct content document:
https://textbookfull.com/product/architecting-asp-net-core-applications-an-atypical-des
ign-patterns-guide-for-net-8-c-12-and-beyond-3rd-edition-early-access-carl-hugo-mar
cotte/
More products digital (pdf, epub, mobi) instant
download maybe you interests ...
Architecting ASP.NET Core Applications Carl-Hugo

Marcotte
https://textbookfull.com/product/architecting-asp-net-core-
applications-carl-hugo-marcotte/
Biota Grow 2C gather 2C cook Loucas
https://textbookfull.com/product/biota-grow-2c-gather-2c-cook-
loucas/
C# 12 and .NET 8 – Modern Cross-Platform Development

Fundamentals: Start building websites and services with
ASP.NET Core 8, Blazor, and EF Core 8, 8th Edition Mark
J. Price
https://textbookfull.com/product/c-12-and-net-8-modern-cross-
platform-development-fundamentals-start-building-websites-and-
services-with-asp-net-core-8-blazor-and-ef-core-8-8th-edition-
mark-j-price/
C 8 0 and NET Core 3 0 Modern Cross Platform

Development Build applications with C NET Core Entity
Framework Core ASP NET Core and ML NET using Visual
Studio Code 4th Edition Mark J. Price
https://textbookfull.com/product/c-8-0-and-net-core-3-0-modern-
cross-platform-development-build-applications-with-c-net-core-
entity-framework-core-asp-net-core-and-ml-net-using-visual-
Design Patterns in .NET Core 3: Reusable Approaches in
C# and F# for Object-Oriented Software Design 2nd
Edition Dmitri Nesteruk
https://textbookfull.com/product/design-patterns-in-net-
core-3-reusable-approaches-in-c-and-f-for-object-oriented-
software-design-2nd-edition-dmitri-nesteruk/
Modern Data Access with Entity Framework Core: Database

Programming Techniques for .NET, .NET Core, UWP, and
Xamarin with C# 1st Edition Holger Schwichtenberg
https://textbookfull.com/product/modern-data-access-with-entity-
framework-core-database-programming-techniques-for-net-net-core-
uwp-and-xamarin-with-c-1st-edition-holger-schwichtenberg/
Modern Data Access with Entity Framework Core: Database

Programming Techniques for . NET, . NET Core, UWP, and
Xamarin with C# 1st Edition Holger Schwichtenberg
https://textbookfull.com/product/modern-data-access-with-entity-
framework-core-database-programming-techniques-for-net-net-core-
uwp-and-xamarin-with-c-1st-edition-holger-schwichtenberg-2/
Pro C# 7 with .NET and .NET Core Andrew Troelsen
https://textbookfull.com/product/pro-c-7-with-net-and-net-core-
andrew-troelsen/
C# 12 and .NET 8 – Modern Cross-Platform Development

Fundamentals, Eighth Edition Mark J. Price
https://textbookfull.com/product/c-12-and-net-8-modern-cross-
platform-development-fundamentals-eighth-edition-mark-j-price/
Architecting ASP.NET Core
Applications
Copyright © 2023 Packt Publishing
All rights reserved. No part of this book may be reproduced, stored in

a retrieval system, or transmitted in any form or by any means,
without the prior written permission of the publisher, except in the
case of brief quotations embedded in critical articles or reviews.
Every effort has been made in the preparation of this book to ensure
the accuracy of the information presented. However, the information
contained in this book is sold without warranty, either express or
implied. Neither the author, nor Packt Publishing, and its dealers
and distributors will be held liable for any damages caused or alleged
to be caused directly or indirectly by this book.
Packt Publishing has endeavored to provide trademark information

about all of the companies and products mentioned in this book by
the appropriate use of capitals. However, Packt Publishing cannot
guarantee the accuracy of this information.
Early Access Publication: Architecting ASP.NET Core

Applications
Early Access Production Reference: B19826
Published by Packt Publishing Ltd.
Livery Place
35 Livery Street
Birmingham
B3 2PB, UK
ISBN: 978-1-80512-338-5
www.packt.com
Table of Contents
1. Architecting ASP.NET Core Applications, Third Edition: An
atypical design patterns guide for .NET 8, C# 12, and beyond
2. 1 Introduction
I. Before you begin: Join our book community on Discord
II. What is a design pattern?
III. Anti-patterns and code smells
i. Anti-patterns
ii. Code smells
IV. Understanding the web – request/response
V. Getting started with .NET
i. .NET SDK versus runtime
ii. .NET 5+ versus .NET Standard
iii. Visual Studio Code versus Visual Studio versus the
command-line interface
iv. Technical requirements
VI. Summary
VII. Questions
VIII. Further reading
3. 2 Automated Testing
II. Introduction to automated testing
i. Unit testing
ii. Integration testing
iii. End-to-end testing
iv. Other types of tests
v. Picking the right test style
III. Testing approaches
i. TDD
ii. ATDD
iii. BDD
iv. Refactoring
v. Technical debt
IV. Testing techniques
i. White-box testing
ii. Black-box testing
iii. Grey-box testing
iv. White-box vs. Black-box vs. Grey-box testing
v. Conclusion
V. Test case creation
i. Equivalence Partitioning
ii. Boundary Value Analysis
iii. Decision Table Testing
iv. State Transition Testing
v. Use Case Testing
VI. How to create an xUnit test project
VII. Key xUnit features
i. Facts
ii. Assertions
iii. Theories
iv. Closing words
VIII. Arrange, Act, Assert
IX. Organizing your tests
i. Unit tests
ii. Integration tests
X. Writing ASP.NET Core integration tests
i. Classic web application
ii. Minimal hosting
XI. Important testing principles
XII. Summary
XIII. Questions
XIV. Further reading
4. 3 Architectural Principles
II. Separation of concerns (SoC)
III. Don’t repeat yourself (DRY)
IV. Keep it simple, stupid (KISS)
V. The SOLID principles
i. Single responsibility principle (SRP)
ii. Open/Closed principle (OCP)
iii. Liskov substitution principle (LSP)
iv. Interface segregation principle (ISP)
v. Dependency inversion principle (DIP)
VI. Summary
VII. Questions
5. 4 REST APIs
II. REST & HTTP
i. HTTP methods
ii. HTTP Status code
iii. HTTP headers
iv. Versioning
v. Wrapping up
III. Data Transfer Object (DTO)
i. Goal
ii. Design
iii. Conceptual examples
iv. Conclusion
IV. API contracts
i. Code-first API Contract
ii. Wrapping up
V. Summary
VI. Questions
VII. Further reading
VIII. Answers
6. 5 Minimal API
II. Top-level statements
III. Minimal Hosting
IV. Minimal APIs
i. Map route-to-delegate
ii. Configuring endpoints
iii. Leveraging endpoint filters
iv. Leveraging the endpoint filter factory
v. Organizing endpoints
V. Using Minimal APIs with Data Transfer Objects
i. Goal
ii. Design
iii. Project – Minimal API
iv. Conclusion
VI. Summary
VII. Questions
IX. Answers
7. 6 Model-View-Controller
II. The Model View Controller design pattern
i. Goal
ii. Design
iii. Anatomy of ASP.NET Core web APIs
iv. Conclusion
III. Using MVC with DTOs
i. Goal
ii. Design
iii. Project – MVC API
iv. Conclusion
IV. Summary
V. Questions
VI. Further reading
VII. Answers
8. 7 Strategy, Abstract Factory, and Singleton Design Patterns
II. The Strategy design pattern
i. Goal
ii. Design
iii. Project – Strategy
iv. Conclusion
III. The Abstract Factory design pattern
i. Goal
ii. Design
iii. Project – Abstract Factory
iv. Project – The mid-range vehicle factory
v. Impacts of the Abstract Factory
vi. Conclusion
IV. The Singleton design pattern
i. Goal
ii. Design
iii. An alternate (better) way
iv. Code smell – Ambient Context
v. Conclusion
V. Summary
VI. Questions
VII. Answers
9. 8 Dependency Injection
II. What is dependency injection?
i. The composition root
ii. Striving for adaptability
iii. Understanding the use of the IoC container
iv. The role of an IoC container
v. Code smell – Control Freak
vi. Object lifetime
vii. Registering our dependencies
viii. Registering your features elegantly
ix. Using external IoC containers
III. Revisiting the Strategy pattern
i. Constructor injection
ii. Property injection
iii. Method injection
iv. Project – Strategy
v. Conclusion
IV. Understanding guard clauses
V. Revisiting the Singleton pattern
i. Project – Application state
ii. Project – Wishlist
iii. Conclusion
VI. Understanding the Service Locator pattern
i. Project – ServiceLocator
ii. Conclusion
VII. Revisiting the Factory pattern
i. Project – Factory
VIII. Summary
IX. Questions
X. Further reading
XI. Answers
10. 9 Options, Settings, and Configuration
II. Loading the configuration
III. Learning the building blocks
i. IOptionsMonitor<TOptions>
ii. IOptionsFactory<TOptions>
iii. IOptionsSnapshot<TOptions>
iv. IOptions<TOptions>
IV. Project – CommonScenarios
i. Manual configuration
ii. Using the settings file
iii. Injecting options
iv. Named options
v. Reloading options at runtime
V. Project – OptionsConfiguration
i. Creating the program
ii. Configuring the options
iii. Implementing a configurator object
iv. Adding post-configuration
v. Using multiple configurator objects
vi. Exploring other configuration possibilities
VI. Project – OptionsValidation
i. Eager validation
ii. Data annotations
iii. Validation types
VII. Project – OptionsValidationFluentValidation
VIII. Workaround – Injecting options directly
IX. Project – Centralizing the configuration
X. Using the configuration-binding source generator
i. Project – ConfigurationGenerators: Part 1
XI. Using the options validation source generator
i. Project – ConfigurationGenerators: Part 2
XII. Using the ValidateOptionsResultBuilder class
i. Project - ValidateOptionsResultBuilder
XIII. Summary
XIV. Questions
XV. Further reading
XVI. Answers
11. 10 Logging patterns
II. About logging
III. Writing logs
IV. Log levels
V. Logging providers
VI. Configuring logging
VII. Structured logging
VIII. Summary
IX. Questions
X. Further reading
XI. Answers
12. 11 Structural Patterns
II. Implementing the Decorator design pattern
i. Goal
ii. Design
iii. Project – Adding behaviors
iv. Project – Decorator using Scrutor
v. Conclusion
III. Implementing the Composite design pattern
i. Goal
ii. Design
iii. Project – BookStore
iv. Conclusion
IV. Implementing the Adapter design pattern
i. Goal
ii. Design
iii. Project – Greeter
iv. Conclusion
V. Implementing the Façade design pattern
i. Goal
ii. Design
iii. Project – The façades
iv. Conclusion
VI. Summary
VII. Questions
IX. Answers
13. 12 Behavioral Patterns
II. Implementing the Template Method pattern
i. Goal
ii. Design
iii. Project – Building a search machine
iv. Conclusion
III. Implementing the Chain of Responsibility pattern
i. Goal
ii. Design
iii. Project – Message interpreter
iv. Conclusion
IV. Mixing the Template Method and Chain of Responsibility
patterns
i. Project – Improved message interpreter
ii. Project – A final, finer-grained design
iii. Conclusion
V. Summary
VI. Questions
VII. Answers
14. 13 Understanding the Operation Result Design Pattern
II. The Operation Result pattern
i. Goal
ii. Design
iii. Project – Implementing different Operation Result
patterns
iv. Advantages and disadvantages
III. Summary
IV. Questions
V. Further reading
VI. Answers
15. 14 Layering and Clean Architecture
II. Introducing layering
i. Classic layering model
ii. Splitting the layers
iii. Layers versus tiers versus assemblies
III. Responsibilities of the common layers
i. Presentation
ii. Domain
iii. Data
IV. Abstract layers
V. Sharing the model
VI. Clean Architecture
VII. Implementing layering in real life
i. To be or not to be a purist?
ii. Building a façade over a database
VIII. Summary
IX. Questions
X. Further reading
XI. Answers
16. 15 Object Mappers, Aggregate Services, and Façade
II. Object mapper
i. Goal
ii. Design
iii. Project – Mapper
iv. Conclusion
III. Code smell – Too many dependencies
IV. Pattern – Aggregate Services
V. Pattern – Mapping Façade
VI. Project – Mapping service
VII. Project – AutoMapper
VIII. Project – Mapperly
IX. Summary
X. Questions
XI. Further reading
XII. Answers
17. 16 Mediator and CQRS Design Patterns
II. A high-level overview of Vertical Slice Architecture
III. Implementing the Mediator pattern
i. Goal
ii. Design
iii. Project – Mediator (IMediator)
iv. Project – Mediator (IChatRoom)
v. Conclusion
IV. Implementing the CQS pattern
i. Goal
ii. Design
iii. Project – CQS
iv. Conclusion
V. Code smell – Marker Interfaces
i. Metadata
ii. Dependency identifier
VI. Using MediatR as a mediator
i. Project – Clean Architecture with MediatR
ii. Conclusion
VII. Summary
VIII. Questions
IX. Further reading
X. Answers
18. 17 Getting Started with Vertical Slice Architecture
II. Anti-pattern – Big Ball of Mud
III. Vertical Slice Architecture
i. What are the advantages and disadvantages?
ii. Project – Vertical Slice Architecture
iii. Conclusion
IV. Continuing your journey: A few tips and tricks
V. Summary
VI. Questions
VII. Further reading
VIII. Answers
19. 18 Request-EndPoint-Response (REPR) and Minimal APIs
II. Request-EndPoint-Response (REPR) pattern
i. Goal
ii. Design
iii. Project – SimpleEndpoint
iv. Conclusion
III. Project – REPR—A slice of the real-world
i. Assembling our stack
ii. Dissecting the code structure
iii. Exploring the shopping basket
iv. Managing exception handling
v. Grey-box testing
IV. Summary
V. Questions
VI. Further reading
VII. Answers
20. 19 Introduction to Microservices Architecture
II. What are microservices?
i. Cohesive unit of business
ii. Ownership of data
iii. Microservice independence
III. An introduction to event-driven architecture
i. Domain events
ii. Integration events
iii. Application events
iv. Enterprise events
v. Conclusion
IV. Getting started with message queues
i. Conclusion
V. Implementing the Publish-Subscribe pattern
i. Message brokers
ii. The event sourcing pattern
iii. Example
iv. Conclusion
VI. Introducing Gateway patterns
i. Gateway Routing pattern
ii. Gateway Aggregation pattern
iii. Backend for Frontend pattern
iv. Mixing and matching gateways
v. Conclusion
VII. Project – REPR.BFF
i. Layering APIs
ii. Running the microservices
iii. Creating typed HTTP clients using Refit
iv. Creating a service that serves the current customer
v. Features
vi. Conclusion
VIII. Revisiting the CQRS pattern
i. Advantages and potential risks
ii. Conclusion
IX. Exploring the Microservice Adapter pattern
i. Adapting an existing system to another
ii. Decommissioning a legacy application
iii. Adapting an event broker to another
iv. Conclusion
X. Summary
XI. Questions
XII. Further reading
XIII. Answers
21. 20 Modular Monolith
II. What is a Modular Monolith?
i. What are traditional Monoliths?
ii. What are microservices?
III. Advantages of Modular Monoliths
IV. Key Components of a Modular Monolith
V. Implementing a Modular Monolith
i. Planning the project
ii. Defining our stack
VI. Project—Modular Monolith
i. Sending events from the catalog module
ii. Consuming the events from the basket module
iii. Inside the aggregator
iv. Exploring the REST API HttpClient
v. Sending HTTP requests to the API
vi. Validating the existence of a product
VII. Transitioning to Microservices
VIII. Challenges and Pitfalls
IX. Conclusion
X. Questions
XI. Further reading
XII. An end is simply a new beginning
XIII. Answers
Architecting ASP.NET Core
Applications, Third Edition: An
atypical design patterns guide for
.NET 8, C# 12, and beyond
Welcome to Packt Early Access. We’re giving you an exclusive
preview of this book before it goes on sale. It can take many months
to write a book, but our authors have cutting-edge information to
share with you today. Early Access gives you an insight into the latest
developments by making chapter drafts available. The chapters may
be a little rough around the edges right now, but our authors will
update them over time.You can dip in and out of this book or follow
along from start to finish; Early Access is designed to be flexible. We
hope you enjoy getting to know more about the process of writing a
Packt book.
1. Chapter 1: Introduction
2. Chapter 2: Automated Testing
3. Chapter 3: Architectural Principles
4. Chapter 4: REST APIs
5. Chapter 5: Minimal API
6. Chapter 6: Model-View-Controller
7. Chapter 7: Strategy, Abstract Factory, and Singleton Design
Patterns
8. Chapter 8: Dependency Injection
9. Chapter 9: Options, Settings, and Configuration
10. Chapter 10: Logging patterns
11. Chapter 11: Structural Patterns
12. Chapter 12: Behavioral Patterns
13. Chapter 13: Understanding the Operation Result Design Pattern
14. Chapter 14: Layering and Clean Architecture
15. Chapter 15: Object Mappers, Aggregate Services, and Façade
16. Chapter 16: Mediator and CQRS Design Patterns
17. Chapter 17: Getting Started with Vertical Slice Architecture
18. Chapter 18: Request-EndPoint-Response (REPR) and Minimal
APIs
19. Chapter19: Introduction to Microservices Architecture
20. Chapter20: Modular Monolith
1 Introduction
Before you begin: Join our book community on Discord
Give your feedback straight to the author himself and chat to other early readers on our Discord
server (find the "architecting-aspnet-core-apps-3e" channel under EARLY ACCESS
SUBSCRIPTION).
https://packt.link/EarlyAccess
The goal of this book is not to create yet another design pattern book; instead, the chapters are
organized according to scale and topic, allowing you to start small with a solid foundation and build
slowly upon it, just like you would build a program.Instead of a guide covering a few ways of
applying a design pattern, we will explore the thought processes behind the systems we are designing
from a software engineer’s point of view.This is not a magic recipe book; from experience, there is no
magical recipe when designing software; there are only your logic, knowledge, experience, and
analytical skills. Let’s define “experience” as your past successes and failures. And don’t worry, you
will fail during your career, but don’t get discouraged by it. The faster you fail, the faster you can
recover and learn, leading to successful products. Many techniques covered in this book should help
you achieve success. Everyone has failed and made mistakes; you aren’t the first and certainly won’t
be the last. To paraphrase a well-known saying by Roosevelt: the people that never fail are the ones
who never do anything.At a high level:
This book explores basic patterns, unit testing, architectural principles, and some ASP.NET Core
mechanisms.
Then, we move up to the component scale, exploring patterns oriented toward small chunks of
software and individual units.
After that, we move to application-scale patterns and techniques, exploring ways to structure an
application.
Some subjects covered throughout the book could have a book of their own, so after this book,
you should have plenty of ideas about where to continue your journey into software architecture.
Here are a few pointers about this book that are worth mentioning:
The chapters are organized to start with small-scale patterns and then progress to higher-level
ones, making the learning curve easier.
Instead of giving you a recipe, the book focuses on the thinking behind things and shows the
evolution of some techniques to help you understand why the shift happened.
Many use cases combine more than one design pattern to illustrate alternate usage so you can
understand and use the patterns efficiently. This also shows that design patterns are not beasts
to tame but tools to use, manipulate, and bend to your will.
As in real life, no textbook solution can solve all our problems; real problems are always more
complicated than what’s explained in textbooks. In this book, I aim to show you how to mix and
match patterns to think “architecture” instead of giving you step-by-step instructions to
reproduce.
The rest of the introduction chapter introduces the concepts we explore throughout the book,
including refreshers on a few notions. We also touch on .NET, its tooling, and some technical
requirements.In this chapter, we cover the following topics:
What is a design pattern?

Anti-patterns and code smell.
Understanding the web – request/response.
Getting started with .NET.
What is a design pattern?

Since you just purchased a book about design patterns, I guess you have some idea of what design
patterns are, but let’s make sure that we are on the same page.Abstract definition: A design
pattern is a proven technique that we can use to solve a specific problem.In this book, we apply
different patterns to solve various problems and leverage some open-source tools to go further,
faster! Abstract definitions make people sound smart, but understanding concepts requires more
practice, and there is no better way to learn than by experimenting with something, and design
patterns are no different.If that definition does not make sense to you yet, don’t worry. You should
have enough information by the end of the book to correlate the multiple practical examples and
explanations with that definition, making it crystal clear.I like to compare programming to playing
with LEGO® because what you have to do is very similar: put small pieces together to create
something bigger. Therefore, if you lack imagination or skills, possibly because you are too young,
your castle might not look as good as someone with more experience. With that analogy in mind, a
design pattern is a plan to assemble a solution that fits one or more scenarios, like the tower of a
castle. Once you designed a single tower, you can build multiple by following the same steps. Design
patterns act as that tower plan and give you the tools to assemble reliable pieces to improve your
masterpiece (program).However, instead of snapping LEGO® blocks together, you nest code blocks
and interweave objects in a virtual environment!Before going into more detail, well-thought-out
applications of design patterns should improve your application designs. That is true whether
designing a small component or a whole system. However, be careful: throwing patterns into the mix
just to use them can lead to the opposite result: over-engineering. Instead, aim to write the least
amount of readable code that solves your issue or automates your process.As we have briefly
mentioned, design patterns apply to different software engineering levels, and in this book, we start
small and grow to a cloud-scale! We follow a smooth learning curve, starting with simpler patterns
and code samples that bend good practices to focus on the patterns—finally ending with more
advanced topics and good practices.Of course, some subjects are overviews more than deep dives,
like automated testing, because no one can fit it all in a single book. Nonetheless, I’ve done my best
to give you as much information about architecture-related subjects as possible to ensure the proper
foundations are in place for you to get as much as possible out of the more advanced topics, and I
sincerely hope you’ll find this book a helpful and enjoyable read.Let’s start with the opposite of
design patterns because it is essential to identify wrong ways of doing things to avoid making those
mistakes or to correct them when you see them. Of course, knowing the right way to overcome
specific problems using design patterns is also crucial.
Anti-patterns and code smells

Anti-patterns and code smells are bad architectural practices or tips about possible bad design.
Learning about best practices is as important as learning about bad ones, which is where we start.
The book highlights multiple anti-patterns and code smells to help you get started. Next, we briefly
explore the first few.
Anti-patterns
An anti-pattern is the opposite of a design pattern: it is a proven flawed technique that will most
likely cause you trouble and cost you time and money (and probably give you headaches).An anti-
pattern is a pattern that seems a good idea and seems to be the solution you were looking for, but it
causes more harm than good. Some anti-patterns started as legitimate design patterns and were
labelled anti-patterns later. Sometimes, it is a matter of opinion, and sometimes the classification
can be influenced by the programming language or technologies.Let’s look at an example next. We
will explore some other anti-patterns throughout the book.
Anti-pattern – God Class
A God class is a class that handles too many things. Typically, this class serves as a central entity
which many other classes inherit or use within the application it is the class that knows and manages
everything in the system; it is the class. On the other hand, it is also the class that nobody wants to
update, which breaks the application every time somebody touches it: it is an evil class!The best
way to fix this is to segregate responsibilities and allocate them to multiple classes rather than
concentrating them in a single class. We look at how to split responsibilities throughout the book,
which helps create more robust software.If you have a personal project with a God class at its core,
start by reading the book and then try to apply the principles and patterns you learn to divide that
class into multiple smaller classes that interact together. Try to organize those new classes into
cohesive units, modules, or assemblies.To help fix God classes, we dive into architectural principles
in Chapter 3, Architectural Principles, opening the way to concepts such as responsibility
segregation.
Code smells
A code smell is an indicator of a possible problem. It points to areas of your design that could
benefit from a redesign. By “code smell,” we mean “code that stinks” or “code that does not smell
right.”It is important to note that a code smell only indicates the possibility of a problem; it does not
mean a problem exists. Code smells are usually good indicators, so it is worth analyzing your
software’s “smelly” parts.An excellent example is when a method requires many comments to
explain its logic. That often means that the code could be split into smaller methods with proper
names, leading to more readable code and allowing you to get rid of those pesky comments.Another
note about comments is that they don’t evolve, so what often happens is that the code described by a
comment changes, but the comment remains the same. That leaves a false or obsolete description of
a block of code that can lead a developer astray.The same is also true with method names.
Sometimes, the method’s name and body tell a different story, leading to the same issues.
Nevertheless, this happens less often than orphan or obsolete comments since programmers tend to
read and write code better than spoken language comments. Nonetheless, keep that in mind when
reading, writing, or reviewing code.
Code smell – Control Freak
An excellent example of a code smell is using the new keyword. This indicates a hardcoded
dependency where the creator controls the new object and its lifetime. This is also known as the
Control Freak anti-pattern, but I prefer to box it as a code smell instead of an anti-pattern since
the new keyword is not intrinsically wrong.At this point, you may be wondering how it is possible not
to use the new keyword in object-oriented programming, but rest assured, we will cover that and
expand on the control freak code smell in Chapter 7, Deep Dive into Dependency Injection.
Code smell – Long Methods
The long methods code smell is when a method extends to more than 10 to 15 lines of code. That is
a good indicator that you should think about that method differently. Having comments that
separate multiple code blocks is a good indicator of a method that may be too long.Here are a few
examples of what the case might be:
The method contains complex logic intertwined in multiple conditional statements.

The method contains a big switch block.
The method does too many things.
The method contains duplications of code.
To fix this, you could do the following:
Extract one or more private methods.

Extract some code to new classes.
Reuse the code from external classes.
If you have a lot of conditional statements or a huge switch block, you could leverage a design
pattern such as the Chain of Responsibility, or CQRS, which you will learn about in Chapter 10,
Behavioral Patterns, and Chapter 14, Mediator and CQRS Design Patterns.
Usually, each problem has one or more solutions; you need to spot the problem and then find,
choose, and implement one of the solutions. Let’s be clear: a method containing 16 lines does not
necessarily need refactoring; it could be OK. Remember that a code smell indicates that there might
be a problem, not that there necessarily is one—apply common sense.
Understanding the web – request/response

Before going any further, it is imperative to understand the basic concept of the web. The idea
behind HTTP 1.X is that a client sends an HTTP request to a server, and then the server responds to
that client. That can sound trivial if you have web development experience. However, it is one of the
most important web programming concepts, irrespective of whether you are building web APIs,
websites, or complex cloud applications.Let’s reduce an HTTP request lifetime to the following:
1. The communication starts.

2. The client sends a request to the server.
3. The server receives the request.
4. The server does something with the request, like executing code/logic.
5. The server responds to the client.
6. The communication ends.
After that cycle, the server is no longer aware of the client. Moreover, if the client sends another
request, the server is unaware that it responded to a request earlier for that same client because
HTTP is stateless.There are mechanisms for creating a sense of persistence between requests for
the server to be “aware” of its clients. The most well-known of these is cookies.If we dig deeper, an
HTTP request comprises a header and an optional body. Then, requests are sent using a specific
method. The most common HTTP methods are GET and POST . On top of those, extensively used by
web APIs, we can add PUT , DELETE , and PATCH to that list.Although not every HTTP method accepts
a body, can respond with a body, or should be idempotent, here is a quick reference table:
Method Request has body Response has body Idempotent

GET No* Yes Yes
POST Yes Yes No
PUT Yes No Yes
PATCH Yes Yes No
DELETE May May Yes
* Sending a body with a GET request is not forbidden by the HTTP specifications, but the
semantics of such a request are not defined either. It is best to avoid sending GET requests with
a body.
An idempotent request is a request that always yields the same result, whether it is sent once or
multiple times. For example, sending the same POST request multiple times should create multiple
similar entities, while sending the same DELETE request multiple times should delete a single entity.
The status code of an idempotent request may vary, but the server state should remain the same. We
explore those concepts in more depth in Chapter 4, Model-View-Controller.Here is an example of a
GET request:
GET http: //www.forevolve.com/ HTTP/1.1

Host: www.forevolve.com
Connection: keep-alive
Upgrade-Insecure-Requests: 1
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64)
AppleWebKit/537.36 (KHTML, like Gecko) Chrome/70.0.3538.110 Safari/537.36
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,image/apng,*/*;q=0.8
Accept-Encoding: gzip, deflate
Accept-Language: en-US,en;q=0.9,fr-CA;q=0.8,fr;q=0.7
Cookie: ...
The HTTP header comprises a list of key/value pairs representing metadata that a client wants to
send to the server. In this case, I queried my blog using the GET method and Google Chrome
attached some additional information to the request. I replaced the Cookie header’s value with ...
because it can be pretty large and that information is irrelevant to this sample. Nonetheless, cookies
are passed back and forth like any other HTTP header.
Important note about cookies
The client sends cookies, and the server returns them for every request-response cycle. This
could kill your bandwidth or slow down your application if you pass too much information
back and forth (cookies or otherwise). One good example would be a serialized identity
cookie that is very large.
Another example, unrelated to cookies but that created such a back-and-forth, was the good
old Web Forms ViewState . This was a hidden field sent with every request. That field could
become very large when left unchecked.
Nowadays, with high-speed internet, it is easy to forget about those issues, but they can
significantly impact the user experience of someone on a slow network.
When the server decides to respond to the request, it returns a header and an optional body,
following the same principles as the request. The first line indicates the request’s status: whether it
was successful. In our case, the status code was 200 , which indicates success. Each server can add
more or less information to its response. You can also customize the response with code.Here is the
response to the previous request:
HTTP/1.1 200 OK
Server: GitHub.com
Content-Type: text/html; charset=utf-8
Last-Modified: Wed, 03 Oct 2018 21:35:40 GMT
ETag: W/"5bb5362c-f677"
Access-Control-Allow-Origin: *
Expires: Fri, 07 Dec 2018 02:11:07 GMT
Cache-Control: max-age=600
Content-Encoding: gzip
X-GitHub-Request-Id: 32CE:1953:F1022C:1350142:5C09D460
Content-Length: 10055
Accept-Ranges: bytes
Date: Fri, 07 Dec 2018 02:42:05 GMT
Via: 1.1 varnish
Age: 35
Connection: keep-alive
X-Served-By: cache-ord1737-ORD
X-Cache: HIT
X-Cache-Hits: 2
X-Timer: S1544150525.288285,VS0,VE0
Vary: Accept-Encoding
X-Fastly-Request-ID: 98a36fb1b5642c8041b88ceace73f25caaf07746
<Response body truncated for brevity>
Now that the browser has received the server’s response, it renders the HTML webpage. Then, for
each resource, it sends another HTTP call to its URI and loads it. A resource is an external asset,
such as an image, a JavaScript file, a CSS file, or a font.After the response, the server is no longer
aware of the client; the communication has ended. It is essential to understand that to create a
pseudo-state between each request, we need to use an external mechanism. That mechanism could
be the session-state leveraging cookies, simply using cookies, or some other ASP.NET Core
mechanisms, or we could create a stateless application. I recommend going stateless whenever
possible. We write primarily stateless applications in the book.
Note
If you want to learn more about session and state management, I left a link in the Further
reading section at the end of the chapter.
As you can imagine, the backbone of the internet is its networking stack. The Hypertext Transfer
Protocol (HTTP) is the highest layer of that stack (layer 7). HTTP is an application layer built on
the Transmission Control Protocol (TCP). TCP (layer 4) is the transport layer, which defines
how data is moved over the network (for instance, the transmission of data, the amount of
transmitted data, and error checking). TCP uses the Internet Protocol (IP) layer to reach the
computer it tries to talk to. IP (layer 3) represents the network layer, which handles packet IP
addressing.A packet is a chunk of data that is transmitted over the wire. We could send a large file
directly from a source to a destination machine, but that is not practical, so the network stack breaks
down large items into smaller packets. For example, the source machine breaks a file into multiple
packets, sends them to the target machine, and then the target reassembles them back into the
source file. This process allows numerous senders to use the same wire instead of waiting for the first
transmission to be done. If a packet gets lost in transit, the source machine can also send only that
packet back to the target machine.Rest assured, you don’t need to understand every detail behind
networking to program web applications, but it is always good to know that HTTP uses TCP/IP and
chunks big payloads into smaller packets. Moreover, HTTP/1 limits the number of parallel requests a
browser can open simultaneously. This knowledge can help you optimize your apps. For example, a
high number of assets to load, their size, and the order in which they are sent to the browser can
increase the page load time, the perceived page load time, or the paint time.To conclude this subject
and not dig too deep into networking, HTTP/1 is older but foundational. HTTP/2 is more efficient
and supports streaming multiple assets using the same TCP connection. It also allows the server to
send assets to the client before it requests the resources, called a server push.If you find HTTP
interesting, HTTP/2 is an excellent place to start digging deeper, as well as the HTTP/3 proposed
standard that uses the QUIC transport protocol instead of HTTP (RFC 9114). ASP.NET Core 7.0+
supports HTTP/3, which is enabled by default in ASP.NET Core 8.0.Next, let’s quickly explore .NET.
Getting started with .NET

A bit of history: .NET Framework 1.0 was first released in 2002. .NET is a managed framework that
compiles your code into an Intermediate Language (IL) named Microsoft Intermediate
Language (MSIL). That IL code is then compiled into native code and executed by the Common
Language Runtime (CLR). The CLR is now known simply as the .NET runtime. After releasing
several versions of .NET Framework, Microsoft never delivered on the promise of an interoperable
stack. Moreover, many flaws were built into the core of .NET Framework, tying it to Windows.Mono,
an open-source project, was developed by the community to enable .NET code to run on non-
Windows OSes. Mono was used and supported by Xamarin, acquired by Microsoft in 2016. Mono
enabled .NET code to run on other OSes like Android and iOS. Later, Microsoft started to develop an
official cross-platform .NET SDK and runtime they named .NET Core.The .NET team did a
magnificent job building ASP.NET Core from the ground up, cutting out compatibility with the older
.NET Framework versions. That brought its share of problems at first, but .NET Standard alleviated
the interoperability issues between the old .NET and the new .NET.After years of improvements and
two major versions in parallel (Core and Framework), Microsoft reunified most .NET technologies
into .NET 5+ and the promise of a shared Base Class Library (BCL). With .NET 5, .NET Core
simply became .NET while ASP.NET Core remained ASP.NET Core. There is no .NET “Core” 4, to
avoid any potential confusion with .NET Framework 4.X.New major versions of .NET release every
year now. Even-number releases are Long-Term Support (LTS) releases with free support for 3
years, and odd-number releases (Current) have free support for only 18 months.The good thing
behind this book is that the architectural principles and design patterns covered should remain
relevant in the future and are not tightly coupled with the versions of .NET you are using. Minor
changes to the code samples should be enough to migrate your knowledge and code to new
versions.Next, let’s cover some key information about the .NET ecosystem.
.NET SDK versus runtime

You can install different binaries grouped under SDKs and runtimes. The SDK allows you to build
and run .NET programs, while the runtime only allows you to run .NET programs.As a developer,
you want to install the SDK on your deployment environment. On the server, you want to install the
runtime. The runtime is lighter, while the SDK contains more tools, including the runtime.
.NET 5+ versus .NET Standard

When building .NET projects, there are multiple types of projects, but basically, we can separate
them into two categories:
Applications
Libraries
Applications target a version of .NET, such as net5.0 and net6.0 . Examples of that would be an
ASP.NET application or a console application.Libraries are bundles of code compiled together, often
distributed as a NuGet package. .NET Standard class library projects allow sharing code between
.NET 5+, and .NET Framework projects. .NET Standard came into play to bridge the compatibility
gap between .NET Core and .NET Framework, which eased the transition. Things were not easy
when .NET Core 1.0 first came out.With .NET 5 unifying all the platforms and becoming the future of
the unified .NET ecosystem, .NET Standard is no longer needed. Moreover, app and library authors
should target the base Target Framework Moniker (TFM), for example, net8.0 . You can also
target netstandard2.0 or netstandard2.1 when needed, for example, to share code with .NET
Framework. Microsoft also introduced OS-specific TFMs with .NET 5+, allowing code to use OS-
specific APIs like net8.0-android and net8.0-tvos . You can also target multiple TFMs when
needed.
Note
I’m sure we will see .NET Standard libraries stick around for a while. All projects will not
just migrate from .NET Framework to .NET 5+ magically, and people will want to continue
sharing code between the two.
The next versions of .NET are built over .NET 5+, while .NET Framework 4.X will stay where it is
today, receiving only security patches and minor updates. For example, .NET 8 is built over .NET 7,
iterating over .NET 6 and 5.Next, let’s look at some tools and code editors.
Visual Studio Code versus Visual Studio versus the command-line interface
How can one of these projects be created? .NET Core comes with the dotnet command-line
interface (CLI), which exposes multiple commands, including new . Running the dotnet new
command in a terminal generates a new project.To create an empty class library, we can run the
following commands:
md MyProject
cd MyProject
dotnet new classlib
That would generate an empty class library in the newly created MyProject directory.The -h option
helps discover available commands and their options. For example, you can use dotnet -h to find
the available SDK commands or dotnet new -h to find out about options and available templates.It
is fantastic that .NET now has the dotnet CLI. The CLI enables us to automate our workflows in
continuous integration (CI) pipelines while developing locally or through any other process.The
CLI also makes it easier to write documentation that anyone can follow; writing a few commands in a
terminal is way easier and faster than installing programs like Visual Studio and emulators.Visual
Studio Code is my favourite text editor. I don’t use it much for .NET coding, but I still do to
reorganize projects, when it’s CLI time, or for any other task that is easier to complete using a text
editor, such as writing documentation using Markdown, writing JavaScript or TypeScript, or
managing JSON, YAML, or XML files. To create a C# project, a Visual Studio solution, or to add a
NuGet package using Visual Studio Code, open a terminal and use the CLI.As for Visual Studio, my
favourite C# IDE, it uses the CLI under the hood to create the same projects, making it consistent
between tools and just adding a user interface on top of the dotnet new CLI command.You can
create and install additional dotnet new project templates in the CLI or even create global tools. You
can also use another code editor or IDE if you prefer. Those topics are beyond the scope of this book.
An overview of project templates
Here is an example of the templates that are installed ( dotnet new --list ):
Figure 1.1: Project templates
A study of all the templates is beyond the scope of this book, but I’d like to visit the few that are
worth mentioning, some of which we will use later:
dotnet new console creates a console application
dotnet new classlib creates a class library
dotnet new xunit creates an xUnit test project
dotnet new web creates an empty web project
dotnet new mvc scaffolds an MVC application
dotnet new webapi scaffolds a web API application
Running and building your program
If you are using Visual Studio, you can always hit the play button, or F5, and run your app. If you are
using the CLI, you can use one of the following commands (and more). Each of them also offers
different options to control their behaviour. Add the -h flag with any command to get help on that
command, such as dotnet build -h :
Command Description
dotnet restore Restore the dependencies (a.k.a. NuGet packages) based on the .csproj or
.sln file present in the current dictionary.
dotnet build Build the application based on the .csproj or .sln file present in the current
dictionary. It implicitly runs the restore command first.
dotnet run Run the current application based on the .csproj file present in the current
dictionary. It implicitly runs the build and restore commands first.
dotnet watch run Watch for file changes. When a file has changed, the CLI updates the code from
that file using the hot-reload feature. When that is impossible, it rebuilds the
application and then reruns it (equivalent to executing the run command
again). If it is a web application, the page should refresh automatically.
dotnet test Run the tests based on the .csproj or .sln file present in the current directory.
It implicitly runs the build and restore commands first. We cover testing in
the next chapter.
dotnet watch test Watch for file changes. When a file has changed, the CLI reruns the tests
(equivalent to executing the test command again).
dotnet publish Publish the current application, based on the .csproj or .sln file present in
the current directory, to a directory or remote location, such as a hosting
provider. It implicitly runs the build and restore commands first.
dotnet pack Create a NuGet package based on the .csproj or .sln file present in the
current directory. It implicitly runs the build and restore commands first. You
don’t need a .nuspec file.
dotnet clean Clean the build(s) output of a project or solution based on the .csproj or .sln
file present in the current directory.
Technical requirements
Throughout the book, we will explore and write code. I recommend installing Visual Studio, Visual
Studio Code, or both to help with that. I use Visual Studio and Visual Studio Code. Other alternatives
are Visual Studio for Mac, Riders, or any other text editor you choose.Unless you install Visual
Studio, which comes with the .NET SDK, you may need to install it. The SDK comes with the CLI we
explored earlier and the build tools for running and testing your programs. Look at the README.md
file in the GitHub repository for more information and links to those resources.The source code of all
chapters is available for download on GitHub at the following address: https://adpg.link/net6.
Summary
This chapter looked at design patterns, anti-patterns, and code smells. We also explored a few of
them. We then moved on to a recap of a typical web application’s request/response cycle.We
continued by exploring .NET essentials, such as SDK versus runtime and app targets versus .NET
Standard. We then dug a little more into the .NET CLI, where I laid down a list of essential
commands, including dotnet build and dotnet watch run . We also covered how to create new
projects. This has set us up to explore the different possibilities we have when building our .NET
applications.In the next two chapters, we explore automated testing and architectural principles.
These are foundational chapters for building robust, flexible, and maintainable applications.
Questions
Let’s take a look at a few practice questions:
1. Can we add a body to a GET request?

2. Why are long methods a code smell?
3. Is it true that .NET Standard should be your default target when creating libraries?
4. What is a code smell?
Further reading
Here are some links to consolidate what has been learned in the chapter:
Overview of how .NET is versioned: https://adpg.link/n52L

.NET CLI overview: https://adpg.link/Lzx3
Custom templates for dotnet new : https://adpg.link/74i2
Session and state management in ASP.NET Core: https://adpg.link/Xzgf
2 Automated Testing
Another random document with
no related content on Scribd:
together with all other facts in the possession of the Executive Department relating
to this matter.
The diplomatic correspondence is herewith transmitted, together with some
correspondence between the naval officers for the time in command in Chilean
waters and the Secretary of the Navy, and also the evidence taken at the Mare
Island navy yard since the arrival of the Baltimore at San Francisco. I do not deem
it necessary in this communication to attempt any full analysis of the
correspondence or of the evidence. A brief restatement of the international
questions involved, and of the reasons why the responses of the Chilean
government are unsatisfactory is all that I deem necessary.
It may be well, at the outset, to say that whatever may have been said in this
country or in Chile in criticism of Mr. Egan, our minister at Santiago, the true
history of the exciting period in Chilean affairs, from the outbreak of the revolution
until this time, discloses no act upon the part of Mr. Egan unworthy of his position,
or that could justly be the occasion of serious animadversion or criticism. He has, I
think, on the whole borne himself in very trying circumstances with dignity,
discretion and courage, and conducted the correspondence with ability, courtesy
and fairness.
It is worth while, also, at the beginning to say that the right of Mr. Egan to give
shelter in the legation to certain adherents of the Balmaceda government who
applied to him for asylum has not been denied by the Chilean authorities, nor has
any demand been made for the surrender of these refugees.
That there was urgent need of asylum is shown by Mr. Egan’s note of August 24,
1891, describing the disorders that prevailed in Santiago, and by the evidence of
Captain Schley as to the pillage and violence that prevailed at Valparaiso. The
correspondence discloses, however, that the request of Mr. Egan for a safe conduct
from the country, in behalf of these refugees, was denied.
The precedents cited by him in the correspondence, particularly the case of the
revolution in Peru in 1865, did not leave the Chilean government in a position to
deny the right of asylum to political refugees, and seemed very clearly to support
Mr. Egan’s contention that a safe conduct to neutral territory was a necessary and
acknowledged incident of the asylum. These refugees have very recently, without
formal safe conduct, but by the acquiescence of the Chilean authorities, been
placed on board the Yorktown, and are now being conveyed to Callao, Peru.
This incident might be considered wholly closed but for the disrespect
manifested towards this government by the close and offensive police surveillance
of the legation premises which was maintained during most of the period of the
stay of the refugees therein.
After the date of my annual message and up to the time of the transfer of the
refugees to the Yorktown, the legation premises seem to have been surrounded by
police, in uniform, and police agents or detectives, in citizens’ dress, who
offensively scrutinized persons entering or leaving the legation, and, on one or
more occasions, arrested members of the minister’s family.
Commander Evans, who, by my direction, recently visited Mr. Egan at Santiago,
in his telegram to the Navy Department described the legation as “a veritable
prison,” and states that the police agents or detectives were, after his arrival,
withdrawn during his stay. It appears further, from the note of Mr. Egan, of
November 20, 1891, that, on one occasion at least, these police agents, whom he
declares to be known to him, invaded the legation premises, pounding upon its
windows and using insulting and threatening language towards persons therein.
This breach of the right of a minister to freedom from police espionage and
restraint seems to have been so flagrant that the Argentine minister, who was dean
of the diplomatic corps, having observed it, felt called upon to protest against it to
the Chilean Minister of Foreign Affairs. The Chilean authorities have, as will be
observed from the correspondence, charged the refugees and the inmates of the
legation with insulting the police; but it seems to me incredible that men whose
lives were in jeopardy and whose safety could only be secured by retirement and
quietness, should have sought to provoke a collision which could only end in their
destruction, or to aggravate their condition by intensifying a popular feeling that at
one time so threatened the legation as to require Minister Egan to appeal to the
Minister of Foreign Affairs.
But the most serious incident disclosed by the correspondence is that of the
attack upon the sailors of the Baltimore in the streets of Valparaiso on the 16th of
October last. In my annual message, speaking upon the information then in my
possession, I said: “So far as I have yet been able to learn, no other explanation of
this bloody work has been suggested than that it had its origin in hostility to those
men as sailors of the United States, wearing the uniform of their government, and
not in any individual act or personal animosity.”
We have now received from the Chilean government an abstract of the
conclusions of the Fiscal General upon the testimony taken by the Judge of Crimes
in an investigation which was made to extend over three months. I very much
regret to be compelled to say that this report does not enable me to modify the
conclusion announced in my annual message. I am still of the opinion that our
sailors were assaulted, beaten, stabbed and killed, not for anything they or any of
them had done, but for what the government of the United States had done, or was
charged with having done by its civil officer and naval commanders. If that be the
true aspect of the case, the injury was to the government of the United States, not
to these poor sailors who were assaulted in the manner so brutal and so cowardly.
Before attempting to give an outline of the facts upon which this conclusion
rests, I think it right to say a word or two upon the legal aspect of the case. The
Baltimore was in the harbor of Valparaiso by virtue of that general invitation which
nations are held to extend to the war vessels of other powers with which they have
friendly relations. This invitation I think must be held ordinarily to embrace the
privilege of such communication with the shore as is reasonable, necessary and
proper for the comfort and convenience of the officers and men of such vessels.
Captain Schley testifies that when his vessel returned to Valparaiso, on September
14th, the city officers, as is customary, extended the hospitalities of the city to his
officers and crew.
It is not claimed that every personal collision or injury in which a sailor or officer
of such naval vessel visiting the shore may be involved raises an international
question; but I am clearly of the opinion that where such sailors or officers are
assaulted by a resident population, animated by hostility to the government whose
uniform these sailors and officers wear, and in resentment of acts done by their
government, not by them, their nation must take notice of the event as one
involving an infraction of its rights and dignity, not in a secondary way as where a
citizen is injured and presents his claim through his own government, but in a
primary way, precisely as if its minister or consul of the flag itself had been the
object of the same character of assault.
The officers and sailors of the Baltimore were in the harbor of Valparaiso under
the orders of their government, not by their own choice. They were upon the shore
by the implied invitation of the government of Chile and with the approval of their
commanding officer, and it does not distinguish their case from that of a consul
that his stay is more permanent or that he holds the express invitation of the local
government to justify his longer residence. Nor does it affect the question that the
injury was the act of a mob. If there had been no participation by the police or
military in this cruel work, and no neglect on their part to extend protection, the
case would still be one, in my opinion, when its extent and character are
considered, involving international rights.
The incidents of the affair are, briefly, as follows: On the 16th of October last,
Captain Schley, commanding the United States steamer Baltimore, gave shore
leave to 117 petty officers and sailors of his ship. These men left the ship about 1.30
P.M. No incident of violence occurred; none of our men were arrested; no complaint
was lodged against them; nor did any collision or outbreak occur until about 6
o’clock P.M. Captain Schley says that he was himself on shore and about the streets
until 5.40 P.M.; that he met very many of his men who were upon leave; that they
were sober and were conducting themselves with propriety, saluting Chilean and
other officers as they met them. Other officers of the ship, and Captain Jenkins, of
the merchant ship Keweenaw, corroborate Captain Schley as to the general
sobriety and good behavior of our men.
The Sisters of Charity at the hospital to which our wounded men were taken,
when inquired of, stated that they were sober when received. If the situation had
been otherwise, we must believe that the Chilean police authorities would have
made arrests. About 6 P.M. the assault began, and it is remarkable that the
investigation by the Judge of Crimes, though so protracted, does not enable him to
give any more satisfactory account of its origin than is found in the statement that
it began between drunken sailors. Repeatedly in the correspondence it is asserted
that it was impossible to learn the precise cause of the riot. The Minister of Foreign
Affairs, Matta, in his telegram to Mr. Montt under date of December 31st, states
that the quarrel began between two sailors in a tavern, and was continued in the
street, persons who were passing joining in it.
The testimony of Talbot, an apprentice, who was with Riggin, is that the
outbreak in which they were involved began by Chilean sailor spitting in the face of
Talbot, which was resented by a knock-down. It appears that Riggin and Talbot
were at that time unaccompanied by any others of their shipmates.
These two men were immediately beset by a crowd of Chilean citizens and
sailors, through which they broke their way to a street car and entered it for safety.
They were pursued, driven from the car, and Riggin was so seriously beaten that he
fell in the street apparently dead. There is nothing in the report of the Chilean
investigation made to us that seriously impeaches this testimony. It appears from
Chilean sources that almost instantly, with a suddenness that strongly implies
premeditation and preparation; a mob, stated by the police authorities at one time
to number 2000, and at another 1000, was engaged in the assault upon our sailors,
who are represented as resisting “with stones, clubs and bright arms.” The report
of the Intendente of October 30th states that the fight began at 6 P.M. in three
streets, which are named, that information was received at the intendencia at 6.15,
and that the police arrived on the scene at 6.30, a full half hour after the assault
began. At that time he says that a mob of 2000 men had collected, and that for
several squares there was the appearance of a “real battle-field.”
The scene at this point is very graphically set before us by the Chilean testimony.
The American sailors, who, after so long an examination, have not been found
guilty of any breach of the peace, so far as the Chilean authorities are able to
discover, unarmed and defenceless, are fleeing for their lives, pursued by
overwhelming numbers, and fighting only to aid their own escape from death or to
succor some mate whose life is in greater peril. Eighteen of them are brutally
stabbed and beaten, while one Chilean seems, from the report, to have suffered
some injury; but how serious or with what character of weapon, or whether by a
missile thrown by our men or by some of his fellow-rioters is unascertained.
The pretense that our men were fighting “with stones, clubs, and bright arms,”
is, in view of these facts, incredible. It is further refuted by the fact that our
prisoners, when searched, were absolutely without arms, only seven penknives
being found in the possession of the men arrested, while there were received by our
men more than thirty stab wounds, every one of which was inflicted in the back,
and almost every contused wound was in the back or back of the head. The
evidence of the ship’s officer of the day is that even the jack-knives of the men were
taken from them before leaving the ship.
As to the brutal nature of the treatment received by our men, the following
extract from the account given of the affair by the La Patria newspaper, of
Valparaiso, of October 17th, cannot be regarded as too friendly: “The Yankees, as
soon as their pursuers gave chase, went by way of the Calle del Arsenal towards the
city car station. In the presence of an ordinary number of citizens, among whom
were some sailors, the North Americans took seats in the street car to escape from
the stones which the Chileans threw at them. It was believed for an instant that the
North Americans had saved themselves from popular fury, but such was not the
case. Scarcely had the car begun to move, when a crowd gathered around and
stopped its progress.
“Under these circumstances, and without any cessation of the howling and
throwing of stones at the North Americans, the conductor entered the car, and
seeing the risk of the situation to the vehicle, ordered them to get out. At the
instant the sailors left the car, in the midst of a hail of stones, the said conductor
received a stone blow on the head. One of the Yankee sailors managed to escape in
the direction of the plaza Wheelright, but the other was felled to the ground by a
stone. Managing to raise himself from the ground where he lay he staggered in an
opposite direction from the station. In front of the house of Señor Mazzini he was
again wounded, falling then senseless and breathless.”
No amount of evasion or subterfuge is able to cloud our clear vision of this brutal
work. It should be noticed, in this connection that the American sailors arrested,
after an examination, were, during the four days following the arrest, every one
discharged, no charge of any breach of the peace or other criminal conduct having
been sustained against a single one of them.
The Judge of Crimes, Foster, in a note to the Intendente, under date of October
22d, before the dispatch from the government, of the following day, which aroused
the authorities of Chile to a better sense of the gravity of the affair, says: “Having
presided temporarily over this court in regard to the seamen of the United States
cruiser Baltimore, who have been tried on account of the deplorable conduct which
took place.” The noticeable point here is that our sailors had been tried before the
22d of October, and that the trial resulted in their acquittal and return to their
vessel.
It is quite remarkable and quite characteristic of the management of this affair
by the Chilean police authorities that we should now be advised that seaman
Davidson, of the Baltimore, has been included in the indictment, his offence being
so far as I have been able to ascertain, that he attempted to defend a shipmate
against an assailant who was striking at him with a knife. The perfect vindication of
our men is furnished by this report; one only is found to have been guilty of
criminal fault, and that for an act clearly justifiable.
As to the part taken by the police in the affair, the case made by Chile is also far
from satisfactory. The point where Riggin was killed is only three minutes walk
from the police station and not more than twice that distance from the
Intendencia; and yet, according to their official report, a full half hour elapsed after
the assault began before the police were upon the ground. It has been stated that
all but two of our men have said that the police did their duty. The evidence taken
at Mare Island shows that if such a statement was procured from our men it was
accomplished by requiring them to sign a writing in a language they did not
understand and by the representation that it was a mere declaration that they had
taken no part in the disturbance. Lieutenant McCrea, who acted as interpreter,
says in his evidence that when our sailors were examined before the Court the
subject of the conduct of the police was so carefully avoided that he reported the
fact to Captain Schley on his return to the vessel.
The evidences of the existence of animosity toward our sailors in the minds of
the Chilean navy and of the populace of Valparaiso are so abundant and various as
to leave no doubt in the mind of any one who will examine the papers submitted. It
manifested itself in threatening and insulting gestures toward our men as they
passed the Chilean men-of-war in their boats, and in the derisive and abusive
epithets with which they greeted every appearance of an American sailor on the
evening of the riot.
Captain Schley reports that boats from the Chilean warships several times went
out of their course to cross the bows of his boats, compelling them to back water.
He complained of the discourtesy, and it was corrected. That this feeling was
shared by men of higher rank is shown by an incident related by Surgeon Stitt, of
the Baltimore. After the battle of Placilla he, with other medical officers of the war
vessels in the harbor, was giving voluntary assistance to the wounded in the
hospitals. The son of a Chilean army officer of high rank was under his care, and
when the father discovered it he flew into a passion and said he would rather have
his son die than have Americans touch him, and at once had him removed from the
ward.
This feeling is not well concealed in the dispatches of the Foreign Office, and had
quite open expression in the disrespectful treatment of the American Legation. The
Chilean boatmen in the bay refused, even for large offers of money, to return our
sailors who crowded the Mole, to their ship when they were endeavoring to escape
from the city on the night of the assault. The market boats of the Baltimore were
threatened, and even quite recently the gig of Commander Evans, of the Yorktown,
was stoned while waiting for him at the Mole.
The evidence of our sailors clearly shows that the attack was expected by the
Chilean people; that threats have been made against our men, and that in one case,
somewhat early in the afternoon, the keeper of one house into which some of our
men had gone, closed his establishment in anticipation of the attack, which he
advised them would be made upon them as darkness came on.
In a report of Captain Schley to the Navy Department he says: “In the only
interview that I had with Judge Foster, who is investigating the case relative to the
disturbance before he was aware of the entire gravity of the matter, he informed
me that the entire assault upon my men was the outcome of hatred for our people
among the lower classes because they thought we had sympathized with the
Balmaceda Government on account of the Itata matter, whether with reason or
without he could, of course, not admit; but such he thought was the explanation of
the assault at that time.”
Several of our men sought security from the mob by such complete or partial
changes in their dress as would conceal the fact of their being seamen of the
Baltimore, and found it then possible to walk the streets without molestation.
These incidents conclusively establish that the attack was upon the uniform—the
nationality—and not upon the men.
The origin of this feeling is probably found in the refusal of this government to
give recognition to the Congressional party before it had established itself, in the
seizure of the Itata for an alleged violation of the Neutrality law in the cable
incident, and in the charge that Admiral Brown conveyed information to
Valparaiso of the landing at Quinteros. It is not my purpose to enter here any
defense of the action of this government in these matters. It is enough for the
present purpose to say that if there was any breach of international comity or duty
on our part it should have been made the subject of official complaint through
diplomatic channels, or of reprisals for which a full responsibility was assumed.
We cannot consent that these incidents and these perversions of the truth shall
be used to excite a murderous attack upon our unoffending sailors and the
Government of Chile go acquit of responsibility. In fact the conduct of this
government during the war in Chile pursued those lines of international duty
which we had so strongly insisted upon on the part of other nations when this
country was in the throes of civil conflict. We continued the established diplomatic
relations with the government in power until it was overthrown, and promptly and
cordially recognized the new government when it was established.
The good offices of this government were offered to bring about a peaceful
adjustment, and the interposition of Mr. Egan to mitigate severities and to shelter
adherents of the Congressional party were effective and frequent. The charge
against Admiral Brown is too base to gain credence with any one who knows his
high personal and professional character.
Recurring to the evidence of our sailors, I think it is shown that there were
several distinct assaults, and so nearly simultaneous as to show that they did not
spread from one point. A press summary of the report of the Fiscal shows that the
evidence of the Chilean officials and others was in conflict as to the place of origin,
several places being named by different witnesses as to the locality where the first
outbreak occurred. This, if correctly reported, shows that there were several
distinct outbreaks, and so nearly at the same time as to cause this confusion.
La Patria, in the same issue from which I have already quoted, after describing
the killing of Riggin and the flight which from that point extended to the Mole,
says: “At the same time in other streets of the port the Yankee sailors fought
fiercely with the people of the town, who believed to see in them incarnate enemies
of the Chilean navy.”
The testimony of Captain Jenkins, of the American merchant ship Keweenaw,
which had gone to Valparaiso for repairs, and who was a witness of some part of
the assault upon the crew of the Baltimore, is strongly corroborative of the
testimony of our own sailors when he says that he saw Chilean sentries drive back
a seaman, seeking shelter, upon a mob that was pursuing him. The officers and
men of Captain Jenkins’ ship furnish the most conclusive testimony as to the
indignities which were practiced toward Americans in Valparaiso. When American
sailors even of merchant ships, can only secure their safety by denying their
nationality, it must be time to readjust our relations with a government that
permits such demonstrations.
As to the participation of the police, the evidence of our sailors shows that our
men were struck and beaten by police officers before and after arrest, and that one,
at least, was dragged with a lasso about his neck by a mounted policeman. That the
death of Riggin was the result of a rifle shot fired by a policeman or soldier on duty
is shown directly by the testimony of Johnson, in whose arms he was at the time,
and by the evidence of Charles Langen, an American sailor, not then a member of
the Baltimore’s crew, who stood close and saw the transaction. The Chilean
authorities do not pretend to fix the responsibility of this shot upon any particular
person, but avow their inability to ascertain who fired it, further than that it was
fired from a crowd.
The character of the wound, as described by one of the surgeons of the
Baltimore, clearly supports his opinion that it was made by a rifle ball, the orifice
of exit being as much as an inch or an inch and a quarter in width. When shot, the
poor fellow was unconscious, and in the arms of a comrade, who was endeavoring
to carry him to a neighboring drug store for treatment. The story of the police, that
in coming up the street they passed these men and left them behind them is
inconsistent with their own statement as to the direction of their approach and
with their duty to protect them, and is clearly disproved. In fact, Riggin was not
behind, but in front of the advancing force, and was not standing in the crowd, but
was unconscious and supported in the arms of Johnson when he was shot.
The communications of the Chilean government in relation to this cruel and
disastrous attack upon our men, as will appear from the correspondence, have not
in any degree taken the form of a manly and satisfactory expression of regret,
much less of apology. The event was of so serious a character that if the injuries
suffered by our men had been wholly the result of an accident in a Chilean port, the
incident was grave enough to have called for some public expression of sympathy
and regret from the local authorities. It is not enough to say that the affair was
lamentable, for humanity would require that expression even if the beating and
killing of our men had been justifiable.
It is not enough to say that the incident is regretted, coupled with the statement
that the affair was not of an unusual character in ports where foreign sailors are
accustomed to meet. It is not for a generous and sincere government to seek for
words of small or equivocal meaning in which to convey to a friendly power an
apology for an offence so atrocious as this. In the case of the assault by a mob in
New Orleans upon the Spanish consulate in 1851, Mr. Webster wrote to the
Spanish minister, Mr. Calderon, that the acts complained of were a “disgraceful
and flagrant breach of duty and propriety,” and that his government “regrets them
as deeply as Minister Calderon or his government could possibly do;” that “these
acts have caused the President great pain, and he thinks a proper acknowledgment
is due to her Majesty’s government.” He invited the Spanish consul to return to his
post, guaranteeing protection, and offering to salute the Spanish flag if the consul
should come in a Spanish vessel. Such a treatment by the government of Chile of
this assault would have been more creditable to the Chilean authorities; and much
less can hardly be satisfactory to a government that values its dignity and honor.
In our note of October 23d last, which appears in the correspondence, after
receiving the report of the board of officers appointed by Captain Schley to
investigate the affair, the Chilean government was advised of the aspect which it
then assumed, and called upon for any facts in its possession that might tend to
modify the unfavorable impression which our report had created. It is very clear
from the correspondence that before the receipt of this note the examination was
regarded by the police authorities as practically closed. It was, however, reopened
and protracted through a period of nearly three months. We might justly have
complained of this unreasonable delay, but in view of the fact that the government
of Chile was still provisional, and with a disposition to be forbearing and hopeful of
a friendly termination, I have awaited the report which has but recently been
made.
On the 21st instant I caused to be communicated to the government of Chile, by
the American minister at Santiago, the conclusions of this government after a full
consideration of all the evidence and of every suggestion affecting this matter, and
to these conclusions I adhere. They were stated as follows:
“First—That the assault is not relieved of the aspect which the early information
of the event gave to it, viz: That an attack was made upon the uniform of the
United States Navy, having its origin and motive in a feeling of hostility to this
government, and not on any account of the sailors or any of them.
“Second—That the public authorities of Valparaiso flagrantly failed in their duty
to protect our men, and that some of the police and of the Chilean soldiers and
sailors were themselves guilty of unprovoked assaults upon our sailors before and
after arrest. He (the President) thinks the preponderance of the evidence and of
the inherent probabilities lead to the conclusion that Riggin was killed by the
police or soldiers.
“Third—That he (the President) is therefore compelled to bring the case back to
the position taken by this government in the note of Mr. Wharton on October 23d
last, *** and to ask for a suitable apology and for some adequate reparation for the
injury done to this country.”
In the same note the attention of the Chilean government was called to the
offensive character of a note addressed by Mr. Matta, its Minister of Foreign
Affairs, to Mr. Montt, its minister at this capital, on the 11th ult. This dispatch was
not officially communicated to this government, but as Mr. Montt was directed to
translate it, and to give it to the press of this country, it seemed to me that it could
not pass without official notice. It was not only undiplomatic, but grossly insulting
to our naval officers and to the Executive Department, as it directly imputed
untruth and insincerity to the reports of the naval officers and to the official
communications made by the Executive Department to Congress. It will be
observed that I have notified the Chilean government that unless this note is at
once withdrawn and an apology as public as the offence made, I will terminate
diplomatic relations.
The request for the recall of Mr. Egan upon the ground that he was not persona
grata, was unaccompanied by any suggestion that could properly be used in
support of it, and I infer that the request is based upon official acts of Mr. Egan,
which have received the approval of this government. But however that may be, I
could not consent to consider such a question until it had first been settled whether
our correspondence with Chile could be conducted upon a basis of mutual respect.
In submitting these papers to Congress for that grave and patriotic consideration
which the questions involved demand, I desire to say that I am of the opinion that
the demands made of Chile by this government should be adhered to and enforced.
If the dignity as well as the prestige and influence of the United States are not to be
wholly sacrificed we must protect those who, in foreign ports, display the flag or
wear the colors of this government against insult, brutality, and death, inflicted in
resentment of the acts of their government, and not for any faults of their own. It
has been my desire in every way to cultivate friendly and intimate relations with all
the governments of this hemisphere.
We do not covet their territory; we desire their peace and prosperity. We look for
no advantage in our relations with them except the increased exchanges of
commerce upon a basis of mutual benefit. We regret every civil contest that
disturbs their peace and paralyzes their development, and are always ready to give
our good offices for the restoration of peace. It must, however, be understood that
this government, while exercising the utmost forbearance towards weaker powers,
will extend its strong and adequate protection to its citizens, to its officers, and to
its humblest sailor, when made the victims of wantonness and cruelty in
resentment, not of their personal misconduct, but of the official acts of their
government.
Upon information received that Patrick Shields, an Irishman and probably a
British subject, but at the time a fireman of the American steamer Keweenaw, in
the harbor of Valparaiso for repairs, had been subjected to personal injuries in that
city—largely by the police—I directed the Attorney-General to cause the evidence of
the officers and crew of that vessel to be taken upon its arrival in San Francisco,
and that testimony is also herewith transmitted.
The brutality and even savagery of the treatment of this poor man by the Chilean
police would be incredible if the evidence of Shields was not supported by other
direct testimony, and by the distressing condition of the man himself when he was
finally able to reach his vessel. The captain of the vessel says:
“He came back a wreck: black from his neck to his hips, from beating; weak and
stupid, and is still in a kind of paralyzed condition, and has never been able to do
duty since.”
A claim for reparation has been made in behalf of this man, for, while he was not
a citizen of the United States, the doctrine long held by us, as expressed in the
Consular Regulations, is:
“The principles which are maintained by this government in regard to the
protection as distinguished from the relief of seamen are well settled. It is held that
the circumstance that the vessel is American is evidence that the seamen on board
are such; and in every regularly documented merchant vessel the crew will find
their protection in the flag that covers them.”
I have as yet received no reply to our note of the 21st inst., but, in my opinion, I
ought not to delay longer to bring these matters to the attention of Congress for
such action as may be deemed appropriate.
Benjamin Harrison.
Executive Mansion, Jan. 25, 1892.

The National Conventions of 1892.
REPUBLICAN.
The National Republican Convention for 1892 was called to meet

at Minneapolis June 7th. The Convention was close at hand before
any candidates were named, other than President Harrison. In
February Mr. Blaine had written to Mr. Clarkson, Chairman of the
National Convention, saying that his name would not be presented as
a candidate, and declining in such positive terms that it was accepted
as meaning what it said at the time. Later on the opposition to the
President’s nomination, led by a syndicate of very strong names—
Platt, of New York; Quay, of Pennsylvania; Clarkson, of Iowa;
Conger, of Ohio; Kellogg, of Louisiana; Wolcott, of Colorado; Bourne,
of Oregon; Filley, of Missouri—agreed to present Mr. Blaine, upon
the statement that he would accept if his nomination was plainly for
the good of the party. Three days preceding the Convention Mr.
Blaine suddenly resigned as Secretary of State, and thus created the
impression that he would accept and that he was a candidate. The
first effect of the resignation was to enthuse his friends, many of
them already assembled at Minneapolis, but when the
correspondence was published, and its terseness was traceable
entirely to Mr. Blaine’s haste, a great reaction followed in all parts of
the country, and groups of businessmen from all prominent towns
and cities wired their delegates of the change in sentiment, and as a
rule they were asked to re-nominate President Harrison. A feeling
affected the Blaine delegates, and many of the leaders began to look
for a third man, in the person of Major McKinley, the father of the
tariff bill of 1890, since chosen Governor of Ohio. Major McKinley
himself voted for Harrison and resisted a proposed stampede in his
own behalf, which had been planned to plump Ohio, Oregon and
Pennsylvania solidly for McKinley. The plan failed, partly because
Harrison had gained largely over estimates after New York had
voted, and Pennsylvania cast 19 votes for him at the only moment
which could have been at all critical.
The Convention organized at noon on the 7th, with Major
McKinley as its President. The first contest was upon the question of
the majority and minority reports of the Committee on Contests, the
majority being adopted and generally regarded as a victory for the
friends of Harrison. The contests were important only in the case of
Alabama, where two full sets of delegates disputed for the seats.
Senator Wolcott, of Colorado, presented the name of Mr. Blaine,
and it was seconded by ex-Senator Warner Miller, of New York.
Ex-Secretary of the Navy Richard T. Thompson, of Indiana (on
that day eighty-three years of age, and a delegate to every previous
Republican National Convention), presented the name of President
Harrison. It was seconded by Chauncey M. Depew, of New York, in a
speech remarkable for its force and eloquence.
The first and only ballot was taken on the morning of June 10th,
with the following result:
THE BALLOT IN DETAIL.
States. Harrison. Blaine. McKinley.
Alabama 15 0 7
Arkansas 15 0 1
California 8 9 1
Colorado 0 8 0
Connecticut 4 0 8
Delaware 4 1 1
Florida 8 0 0
Georgia 26 0 0
Idaho 0 6 0
Illinois 34 14 0
Indiana 30 0 0
Iowa 20 5 1
Kansas 11 0 9
Kentucky 22 2 1
Louisiana 8 8 0
Maine 0 12 0
Maryland 14 0 2
Massachusetts 18 1 11
Michigan 7 2 19
Minnesota 8 9 1
Mississippi 13½ 4½ 0
Missouri 28 4 2
Montana 5 1 0
Nebraska 15 0 1
Nevada 0 6 0
New Hampshire 4 2 0
New Jersey 18 2 0
New York 27 35 10
North Carolina 17⅔ 2⅔ 1
North Dakota 2 4 0
Ohio 1 0 45
Oregon 1 0 7
Pennsylvania 19 3 42
Rhode Island 5 1 1
South Carolina 13 3 2
South Dakota 8 0 0
Tennessee 17 4 3
Texas 22 6 0
Vermont 8 0 0
Virginia 9 13 2
Washington 1 6 1
West Virginia 12 0 0
Wisconsin 19 2 3
Wyoming 4 2 0
Territories.
Alaska 2 0 0
Arizona 1 1 0
Dist. of Columbia 0 2 0
Indian Territory 1 1 0
New Mexico 6 0 0
Oklahoma 2 0 0
Utah 2 0 0
Total 535⅙ 182⅙ 182
Absent and not voting, 1⅔.
Reed, of Maine, received 3 votes, and Lincoln, of Illinois, 1.
Major McKinley moved to make the nomination unanimous, and it
was adopted with great enthusiasm.
In response to the unanimous request of the New York delegation,
Hon. Whitelaw Reid was nominated for Vice-President by
acclamation.
[See Book II. for Platform and Comparison of Platforms; Book III.
for speech of Hon. Chauncey M. Depew.]
DEMOCRATIC.
The Democratic National Convention assembled at Chicago, June

21st, and its deliberations excited great interest because of the
opposition of the New York delegation to the nomination of
Cleveland. Under the leadership of Governor Hill, the New York
Democracy, in the canvass of 1891, carried the State, electing Flower
as Governor, and Hill as U. S. Senator, the latter only after a severe
contest and depriving three Republican State Senators of their seats
by contests settled before partisan courts. The New York opposition
to Cleveland, with the active aid of Tammany, united upon Hill as a
Presidential candidate. A “snap” or mid-winter State Convention was
called to elect delegates to the National Convention, and 72 Hill men
were chosen and instructed. This system of forestalling public
sentiment angered the Cleveland Democrats, who signed a protest to
the number of 200,000 and three months later elected a contesting
delegation, with instructions for Cleveland. Mr. Croker, Tammany’s
Chief, and State Chairman Murphy were the Hill leaders at Chicago,
and they gave early and public notice, in very bitter language, that if
nominated Cleveland could not carry New York. Ex-Secretary of the
Navy Whitney was the Cleveland leader, and he readily mustered
more than two-thirds of the Convention, and felt so assured of
victory that he advised the withdrawal of the contest against Hill’s
delegation. Singularly enough the minority desired the repeal of the
unit rule, for they had ascertained, after a careful canvass, that
Cleveland would lose enough votes to check and possibly prevent his
nomination if all of the delegates were permitted to vote separately.
The unit rule, however, was carefully re-enacted in the report of the
Committee on Rules.
Governor Wm. L. Wilson, of West Virginia, was elected President.
Governor Leon Abbett, of New Jersey, presented the name of Grover
Cleveland; William C. DeWitt, of New York, that of Senator David B.
Hill, and John M. Duncombe, of Iowa, that of Governor Boies. A
ballot was reached at 4 o’clock on the morning of the 23d, the
Cleveland leaders doing this to prevent combinations by the
opposition.
THE BALLOT IN DETAIL.
States. Cleveland. Hill. Boies. Gorman. Scattering.

Alabama 14 2 1 1 4
Arkansas 16 0 0 0 0
California 18 0 0 0 0
Colorado 0 3 5 0 0
Connecticut 12 0 0 0 0
Delaware 6 0 0 0 0
Florida 5 0 0 0 3
Georgia 17 5 0 4 0
Idaho 0 0 6 0 0
Illinois 48 0 0 0 0
Indiana 30 0 0 0 0
Iowa 0 0 26 0 0
Kansas 20 0 0 0 0
Kentucky 18 0 2 0 6
Louisiana 3 1 11 1 0
Maine 9 1 0 1 1
Maryland 6 0 0 9½ 0
Massachusetts 24 4 1 0 1
Michigan 28 0 0 0 0
Minnesota 18 0 0 0 0
Mississippi 8 3 3 4 0
Missouri 34 0 0 0 0
Montana 0 0 6 0 0
Nebraska 15 0 0 1 0
Nevada 0 0 4 2 0
New Hampshire 8 0 0 0 0
New Jersey 20 0 0 0 0
New York 0 72 0 0 0
North Carolina 3⅓ 1 0 0 17⅔
North Dakota 6 0 0 0 0
Ohio 14 6 16 5 5
Oregon 8 0 0 0 0
Pennsylvania 64 0 0 0 0
Rhode Island 8 0 0 0 0
South Carolina 2 3 13 0 0
South Dakota 7 0 1 0 0
Tennessee 24 0 0 0 0
Texas 23 1 6 0 0
Vermont 8 0 0 0 0
Virginia 12 11 0 1 0
Washington 8 0 0 0 0
West Virginia 7 1 0 3 1
Wisconsin 24 0 0 0 0
Wyoming 3 0 0 3 0
Territories
Alaska 2 0 0 0 0
Arizona 5 0 0 1 0
Dist. of Columbia 2 0 0 0 0
New Mexico 4 1 1 0 0
Oklahoma 2 0 0 0 0
Utah 2 0 0 0 0
Indian Territory 2 0 0 0 0
Total 617⅓ 115 103 36½ 38⅔
Number of votes cast, 909½. Necessary to a choice, 607.
Of the scattering votes Campbell got two from Alabama.
Carlisle got 3 from Florida, 6 from Kentucky, 5 from Ohio. Total
14.
Stephenson got 16⅔ from North Carolina.
Pattison got 1 from West Virginia.
Russell got 1 from Massachusetts.
Whitney got 1 from Maine.
Adlai E. Stevenson, of Illinois, former Assistant Postmaster-
General, was nominated Vice-President on the first ballot, his chief
competitor being Senator Gray, of Indiana.
[See Book II. for Democratic National Platform and Comparison;
Book III. for Governor Abbett’s speech nominating Cleveland.]
A notable scene in the Convention was created by Mr. Neal, of
Ohio, who moved to substitute a radical free trade plank as a
substitute for the somewhat moderate utterances reported by ex-
Secretary of the Interior Vilas, who read the report of the Committee
on Platform. The substitute denounced the protective tariff as a
fraud.
Mr. Neal made an earnest speech in support of his substitute and
was ably seconded by Mr. Watterson.
Mr. Vilas replied defending the majority report in a vigorous
speech, which was as generously applauded as that which preceded.
The debate was animated and made specially interesting by the
suggestions and calls from the galleries. The substitute was finally
accepted by Chairman Jones on behalf of the committee, but this did
not satisfy the friends of the substitute, who persisted in having a roll
call upon its adoption.
A synopsis of the platform was submitted to and received the
approval of Mr. Cleveland, and it was reported that the Neal
substitute was prepared by the anti-Cleveland leaders, and the fact
that the roll call was persisted in by the anti-Cleveland men gave
color to this report.
There was a great deal of confusion and excitement preceding the
roll call, and its progress was watched with as much interest as
though its result was to decide the nomination. The States at the
head of the roll generally cast their votes according to what was
believed to be the feeling of their delegations on the Presidency, but
later on the order was more varied, States known to be for Cleveland
casting their solid vote for the substitute. New York was loudly
cheered when the 72 votes of the State were given for the substitute.
It was a most inconsistent vote, as Tammany is not regarded as a free
trade organization—rather as one favoring moderate tariffs. A ripple
of excitement was occasioned when Chairman Hensel cast the 64
votes of Pennsylvania against the substitute. Mr. Wallace protested
that 15 of the delegates favored the substitute, and he demanded that
the delegation be polled. A colloquy followed between Hensel and
Wallace on the rules of the Convention, and the point raised by the
former that Wallace’s motion was not in order under the unit rules
was sustained by the Chair.
The result of the vote was 564 for the substitute and 342 against it.

Applications: An Atypical Design Beyond 3rd Edition (Early Access) Carl-Hugo Marcotte

Uploaded by

Document Information

Original Title

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Applications: An Atypical Design Beyond 3rd Edition (Early Access) Carl-Hugo Marcotte

Uploaded by

Copyright:

Available Formats

Architecting ASP.

Architecting ASP.NET Core Applications Carl-Hugo

Biota Grow 2C gather 2C cook Loucas

C# 12 and .NET 8 – Modern Cross-Platform Development

C 8 0 and NET Core 3 0 Modern Cross Platform

Modern Data Access with Entity Framework Core: Database

Modern Data Access with Entity Framework Core: Database

Pro C# 7 with .NET and .NET Core Andrew Troelsen

C# 12 and .NET 8 – Modern Cross-Platform Development

All rights reserved. No part of this book may be reproduced, stored in

Packt Publishing has endeavored to provide trademark information

Early Access Publication: Architecting ASP.NET Core

Early Access Production Reference: B19826

Published by Packt Publishing Ltd.

What is a design pattern?

What is a design pattern?

Anti-patterns and code smells

Anti-pattern – God Class

Code smell – Control Freak

Code smell – Long Methods

The method contains complex logic intertwined in multiple conditional statements.

To fix this, you could do the following:

Extract one or more private methods.

Understanding the web – request/response

1. The communication starts.

Method Request has body Response has body Idempotent

GET http: //www.forevolve.com/ HTTP/1.1

Important note about cookies

Getting started with .NET

.NET SDK versus runtime

.NET 5+ versus .NET Standard

An overview of project templates

Figure 1.1: Project templates

Running and building your program

1. Can we add a body to a GET request?

Overview of how .NET is versioned: https://adpg.link/n52L

Executive Mansion, Jan. 25, 1892.

The National Republican Convention for 1892 was called to meet

The Democratic National Convention assembled at Chicago, June

States. Cleveland. Hill. Boies. Gorman. Scattering.

You might also like