.NET Summit 2017
15 спикеров из Дании, Израиля, Великобритании, Чехии, Польши, Литвы, России и Беларуси собрались для обсуждения тенденций в разработке на .NET платформе:
- .net at scale (real-world high-load, high-throughput and low latency);
- .net core and .net standard;
- new platforms: xamarin, mono and stuff;
- mvc core;
- .net internals & more.
- Техническим директорам
- Системным администраторам
What do you think C# developers do all day? Write code? Wrong!! They are trying to figure out yesterday’s async pipe, and try to find memory leaks. .NET events are prone to memory leaks, need special treatment to avoid race conditions, and are not first-class citizens in the .NET ecosystem. Task-based programming and async-await keywords make async code more readable, but aren't handy when it comes to composing and require additional treatment when used outside of their regular use cases. With Rx.NET you will learn how we can overcome those downsides by abstracting away all sources of events and providing composition tools in a form of pure-functions to filter, compose and transfer changes in a Reactive(X)-way.
High Load consists of three factors: 1. Latency - The Speed of an individual request, business transaction or event. 2. Throughput - The Scale required to process a number business transactions per time period a.k.a TPS. 3. Availability - The system 99.XXX% availability 24/7/365 AdTech is the technology that supports Digital Marketing. The “free” internet services such as, Email, Facebook, Skype, etc. are funded by Digital marketing. In this talk you will learn the technologies used and how they are implemented to see the High Load demanded by Digital marketing. You will also hear some of the War stories and how problems were solved using predominantly .Net along with other technologies.
There are major performance changes in .NET Core and C# 7. This talk will be a guided tour of most important of them. We’ll see how the new tools: ref returns & locals, ArrayPool, ValueTasks and Spans work and what performance benefits they can bring. This talk will discuss how all these new tools can improve your application performance today with the power of .NET Standard.
I'll tell you how to use JetBrains Rider for convenient and fast software development.
When we come up with a great new product idea, there’s a lot of initial uncertainty. We’re unsure whether it will be successful, sustainable or even wanted by end users. And that’s all before we’ve spent a penny on validating the idea. That’s why it’s vital to prototype an idea and get it into users’ hands as quickly as possible and as cheaply as possible. This talk covers the story of how we at Compositional IT were able to use both F# and Azure Functions to spike out new product ideas in a matter of days. We’ll consider the patterns and practices we’ve discovered which helped us take a product from an idea into something useable within a matter of days whilst also ensuring that we’ve got a product which can scale to reach the demands of a growing product.
Many interesting libraries appeared together with .NET Core and ASP.NET Core release. One of them is Microsoft.Extensions.DependencyInjection which adds a nice foundation to use dependency injection in your applications. In this talk, I'll show the features of this library and how to use it. We will talk about scopes and instance lifetimes, disposing, and how to integrate it with and external DI container like Autofac to be able to inject factories, work with generic types and use more advanced features.
So you've built your HTTP API, and now that it's live, you're suddenly dealing with a whole new set of problems. Do you really need to PUT the entire Customer just to change someone's email address? Why does it take you 25 API calls just to render a shopping cart? How do you find the bottlenecks when just drawing a web page requires fifty HTTP requests? What happens when one of your API consumers accidentally tries to GET your entire customer database? Most of us are familiar with the architectural style known as REST, but even experienced developers often find it difficult to translate REST's architectural principles into running code. In this talk, we'll explore the elements of REST related to hypermedia and the principle of "hypermedia as the engine of application state" (HATEOAS) - we'll talk about why they matter, and when you might want to implement them in your own systems. We'll look at some of the tools that exist to help you design, deliver and debug your HTTP APIs, and we'll do some hands-on coding to show you what these patterns look like in a .NET web application using the NancyFX HTTP framework and the HAL hypermedia application language.
After hundreds of performance investigations, some patterns begin to emerge. You could save a lot of time here, or find the root cause more easily there. In this talk, you'll see what I learned from years of performance work in the field, which processes and tools work, and what I think can still be improved. First, we'll talk about anti-methods for performance investigations and the USE checklist for finding the performance bottleneck, applied specifically to Windows and .NET applications. Then, we'll talk about ideal performance investigation tools and which tools can satisfy these needs today, and review the power of Event Tracing for Windows for extracting hard-to-find information out of the system. I will also announce a couple of my own tools that I haven't talked about before, and that are now open source on GitHub. Finally, we'll talk about dashboards and visualizations, and some non-obvious mistakes you can make when working with statistics and reports. Along the way, I'll take you on a tour of a couple of my most challenging performance investigations.
In the talk I’ll show how to use PDB files effectively. I’ll demonstrate structure of PDB files and why we need them. The talk will save your time on creation of debugging infrastructure inside your organization.
Do you know what developers do most of their day? coding? Copying snippets from StackOverFlow? You wish! They are debugging!! Every developer should look at Software development as a craftsmanship, and like any craftsman, you probably have a set of tools that you use. From a developer's point of view, the main tools in the box are the IDE and Debugger. A developer who is skilled with these tools is usually more productive, as he/she can write more code and fix more bugs - faster, thus being a better developer. In this session I will discuss tips, tricks and advanced methods for debugging .Net Core more easily and efficiently. We will see a variety of tools and techniques for debugging code that looks undebuggable such as complex Linq queries and concurrent code. Join me and start your path to becoming a .Net debugging Jedi.
The .NET garbage collector can be your best friend or your worst enemy; and it’s not friendly with a lot of people. The GC left more than a few production systems burning in smoke after developers failed to anticipate the effects of real production loads on the memory subsystem. In this talk, we will methodically measure and improve the .NET garbage collector’s performance. We will begin with a quick refresher on dynamic performance tools that can identify GC issues: CLR performance counters, ETW GC events, and ETW object allocation events; as well as static analysis tools, such as the Roslyn-based heap allocations analyzer. Then, we will inspect multiple issues at the source code level: excessive boxing, unintended effects of lambdas closing over local variables, await-generated state machines, intermediate objects in LINQ queries, and many others. We will also discuss higher-level memory problems: how to get rid of large object allocations, how to avoid finalization, and how to convert heap-based designs to local objects. Some of these ideas are now being applied at the language and framework level in C# 7 and .NET Core. At the end of the talk, you will be equipped to reduce memory traffic and GC overhead in your own applications, often by a factor of 10 or more!
Launched at this year //build event, project Rome and Microsoft Graph is a new capability that allows developers to create connected experiences across devices and other device platforms (Android, iOS).
Mono is a platform that powers all Xamarin and Unity apps (Have you played Pokemon GO?) Egor will talk about new tools and features of Mono and how it lives side by side with .NET Core.
Xamarin.Forms has come a long way since the days of when its recommended use was for simple apps and prototyping only and in this session, I will show you the advances made and how to utilize them to create beautiful apps yourself. You will see the basic structure of a Xamarin.Forms app and how to use XAML and the built-in controls to create a UI. You’ll learn about the MVVM pattern and data binding so information can be presented and modified in the UI and app logic layer with ease. You’ll walk through accessing platform specific native controls and the end of this session – you’ll be able to create a beautiful app with Xamarin.Forms.