You are viewing content from a past/completed QCon

Workshop: [SOLD OUT] Building and Architecting Web APIs with ASP.NET Core 2.1

Duration: 1:00pm - 4:00pm

Day of week: Thursday

Level: Beginner

Key Takeaways

  • Learn about ASP.NET Core, where it came from and how to start using it for web and API development

  • Learn how to use ASP.NET Core Web API's built-in dependency injection for more robust and easier to maintain projects.

  • Learn how to create routes for your API calls with the MVC pattern.

  • Learn how to work with domain models and data in your API along with caching.

  • Learn how to test and debug your ASP.NET Core Web API solution.

  • Learn advanced architecture techniques in ASP.NET Core Web API

Prerequisites

Strongly recommended that you have some knowledge of the following:

  • C# and .NET Core or .NET Framework
  • LINQ
  • Entity Framework
  • Microsoft SQL Server
  • ASP.NET MVC

You will need the following software installed on your machine.

  • Your favorite .NET IDE
  • .NET Core 2.1
  • Microsoft SQL Server or Windows Azure or AWS account for MSSQL
  • An HTTP debugging tool like Fiddler or Postman
  • Git

Web APIs drive the most popular and powerful web and mobile apps—making the developer who can build a robust web API a developer that's in demand. Get started creating your own with ASP.NET Core, the open-source framework for Windows, macOS, and Linux.

You know you have to have a great experience when you develop your apps, right? The greatest experience for your user's centers around their data. That’s why developing a great set of Web APIs is so important. Using ASP.NET Core Web API is a modern framework for the modern web. The secret to it all is knowing how to architect your Web APIs for the best experience.

Using the architectures (N-Tier and Hexagonal) taught in this talk allows your APIs specifically to work better due to:

  • Allowing a clear decoupling of the API endpoints, Data Access (Synthetic or Production) and finally the Data Domain classes.
  • The API Endpoints (Controllers) have no knowledge or responsibility of Data Domain and behind it Data Access
  • Because of the decoupling and separation of responsibilities testing can be done easily and without issues.
  • Data Access segments of the architecture can easily be switched out without impacting the Domain or API Endpoints.

By using these architectures not only does the development story become easier but your end users get a much more stable API set to consume. The talk will explain and get you started on using these concepts with your ASP.NET Core 2.1 Web API solutions.

We will be building an API for an online music store during this workshop.

Speaker: Chris Woodruff

Developer Advocate @Jetbrains

Chris Woodruff (or Woody as he is commonly known as) has a degree in Computer Science from Michigan State University’s College of Engineering. Woody has been developing and architecting software solutions for over 20 years and has worked in many different platforms and tools. He is a community leader, helping such events as GRDevNight, GRDevDay, West Michigan Day of .NET and Beer City Code. He was also instrumental in bringing the popular Give Camp event to Western Michigan where technology professionals lend their time and development expertise to assist local non-profits. As a speaker and podcaster, Woody has spoken and discussed a variety of topics, including database design and open source. He has been a Microsoft MVP in Visual C#, Data Platform and SQL and was recognized in 2010 as one of the top 20 MVPs world-wide. Woody is a Developer Advocate for JetBrains and evangelizes .NET, .NET Core and JetBrains' products in North America.

Find Chris Woodruff at

Tracks

  • Optimizing Yourself: Human Skills for Individuals

    Better teams start with a better self. Learn practical skills for IC.

  • Modern Data Architectures

    Today’s systems move huge volumes of data. Hear how places like LinkedIn, Facebook, Uber and more built their systems and learn from their mistakes.

  • Practices of DevOps & Lean Thinking

    Practical approaches using DevOps and a lean approach to delivering software.

  • Microservices Patterns & Practices

    What's the last mile for deploying your service? Learn techniques from the world's most innovative shops on managing and operating Microservices at scale.

  • Bare Knuckle Performance

    Killing latency and getting the most out of your hardware

  • Architectures You've Always Wondered About

    Next-gen architectures from the most admired companies in software, such as Netflix, Google, Facebook, Twitter, & more

  • Machine Learning for Developers

    AI/ML is more approachable than ever. Discover how deep learning and ML is being used in practice. Topics include: TensorFlow, TPUs, Keras, PyTorch & more. No PhD required.

  • Production Readiness: Building Resilient Systems

    Making systems resilient involves people and tech. Learn about strategies being used from chaos testing to distributed systems clustering.

  • Regulation, Risk and Compliance

    With so much uncertainty, how do you bulkhead your organization and technology choices? Learn strategies for dealing with uncertainty.

  • Languages of Infrastructure

    This track explores languages being used to code the infrastructure. Expect practices on toolkits and languages like Cloudformation, Terraform, Python, Go, Rust, Erlang.

  • Building & Scaling High-Performing Teams

    To have a high-performing team, everybody on it has to feel and act like an owner. Organizational health and psychological safety are foundational underpinnings to support ownership.

  • Evolving the JVM

    The JVM continues to evolve. We’ll look at how things are evolving. Covering Kotlin, Clojure, Java, OpenJDK, and Graal. Expect polyglot, multi-VM, performance, and more.

  • Trust, Safety & Security

    Privacy, confidentiality, safety and security: learning from the frontlines.

  • JavaScript & Transpiler/WebAssembly Track

    JavaScript is the language of the web. Latest practices for JavaScript development in and how transpilers are affecting the way we work. We’ll also look at the work being done with WebAssembly.

  • Living on the Edge: The World of Edge Compute From Device to Application Edge

    Applied, practical & real-world deep-dive into industry adoption of OS, containers and virtualization, including Linux on.

  • Software Supply Chain

    Securing the container image supply chain (containers + orchestration + security + DevOps).

  • Modern CS in the Real World

    Thoughts pushing software forward, including consensus, CRDT's, formal methods & probabilistic programming.

  • Tech Ethics: The Intersection of Human Welfare & STEM

    What does it mean to be ethical in software? Hear how the discussion is evolving and what is being said in ethics.