Modern Web Development with ASP.NET Core 3 – Second Edition

Modern Web Development with ASP.NET Core 3 - Second Edition

So, my new book is out now! The title changed recently from Mastering ASP.NET Core 3 – Second Edition to Modern Web Development with ASP.NET Core 3 – Second Edition. It was Packt’s decision, and I didn’t really bother about that, although I think the former was more accurate. It’s around 700 pages, and it is divided in three parts:

  • The Fundamentals of ASP.NET Core
  • Improving Productivity
  • Advanced Topics

On the first part, we can find the following chapters:

  1. Getting started with ASP.NET Core
  2. Configuration
  3. Routing
  4. Controllers and Actions
  5. Views

On the second part, we have:

  1. Using Forms and Models
  2. Implementing Razor Pages
  3. API Controllers
  4. Reusable Components
  5. Understanding Filters
  6. Security

Finally, on the third and last:

  1. Logging, Tracing, and Diagnostics
  2. Understanding How Testing Works
  3. Client-Side Development
  4. Improving Performance and Scalability
  5. Real-Time Communication
  6. Introducing Blazor
  7. gRPC and Other Topics
  8. Application Deployment

There is also an appendix on the dotnet tool.

I’d say the highlights are:

  • Configuration and feature management
  • API controllers including versioning and OData
  • Razor Pages
  • SignalR
  • Blazor
  • gRPC

The technical reviewers were Alvin Ashcraft (Microsoft MVP and world famous for Morning Dew) and Prakash Tripathi (Microsoft MVP too).

Should you wish to buy it in the next days, there is a discount code that you can use that will grant you a 50% discount: WEBDEV50.

I hope you enjoy it and I’d like to hear from you about the book! Winking smile

Mastering ASP.NET Core 3.0 – Second Edition

Mastering ASP.NET Core 3.0 - Second Edition

My new book, Mastering ASP.NET Core 3.0 – Second Edition, for Packt Publishing, will be available from June 19. It is a almost total rewrite from my previous one, Mastering ASP.NET Core 2.0, and it covers all of the goodies that ASP.NET Core 3.0 and 3.1 brought along. I cover Razor Pages, Blazor, OData, gRPC and some less-known features as well.

For personal reasons, it was difficult to write, and, in fact, it should have come out long ago, but, if we think about it, if it had, I wouldn’t have had the chance to cover some technologies – such as Blazor WebAssembly – that were only released recently.

I will come back to this with more information, including the table of contents, soon.

In the end, I can say that I am happy with the result, and hope you, dear readers, enjoy it too!

C# 8.0 and .NET Core 3.0 – Modern Cross-Platform Development – Fourth Edition Review

C# 8.0 and .NET Core 3.0 – Modern Cross-Platform Development

This is a book written by Mark J. Price for Packt Publishing. I must say that I don’t know Mark, but I was asked by Pack to review this book, which I gladly did!

The topics covered in this book are vast, so it should be no surprise the size of it: more than 800 pages. It spawns across 21 chapters, each of them ends with some exercises. It talks about pretty much everything .NET, as you can see:

Chapter 1

Introduction to Visual Studio Code and Visual Studio 2019 for Windows and Mac. Presents some useful extensions for Visual Studio Code. Talks a bit about the .NET Framework and its branches and offspring, Xamarin, Mono and .NET Core. Also explains the intermediate language that .NET compiles to and how to produce native code from .NET. Also shows how to use Visual Studio Code to get code from GitHub and build console apps. Finally, it gives some pointers on how to get support from the Internet.

Chapter 2

Presents all the C# versions from 1 until 8, the last one to date. Shows how to enable a specific version on a .NET project. Gives a an overview of the unchanging C# language features, like variables, data types, reference and value types, and presents a simple example on how to get input from the user.

Chapter 3

Expands on the C# language started on the previous chapter introducing branching, conditions, pattern matching, assignment, operators, loops and casts.

Chapter 4

Introduces functions, how to debug and unit test them.

Chapter 5

Explains Object-Oriented Programming with C#. How references to assemblies and namespaces work. Field and property modifiers. How to use the return values of functions, including tuples. Method overloading, optional parameters. Partial classes. Properties with indexers and different levels of access.

Chapter 6

Talks about interfaces and type inheritance. Explains events and delegates. Generic types. Reference and value types. The dispose pattern. Member overriding and hiding. Preventing inheritance. Polymorphism. Casting. Extension methods.

Chapter 7

Packaging .NET components in assemblies and NuGet packages. The .NET Standard and .NET Core. Publishing applications. Decompiling assemblies. Publishing to NuGet. Porting to .NET Core.

Chapter 8

Common .NET types and operations: numbers, string, regular expressions, collections, spans, indexes, ranges, network resources, types, attributes. Internationalization.

Chapter 9

Files, file streams and serialization. Working with the filesystem. Text encoding. XML and JSON serialisation and compression.

Chapter 10

Data encryption and decryption. Data hashing and signing. Random number generation. User authentication and authorisation.

Chapter 11

Database programming with Entity Framework Core.

Chapter 12

Using LINQ. Custom LINQ methods. LINQ to XML. Parallel LINQ.

Chapter 13

Performance monitoring. Tasks. Synchronizing access to shared resources. async and await.

Chapter 14

ASP.NET Core web applications. SignalR. Blazor.

Chapter 15

ASP.NET Core Razor Pages. Using EF Core with ASP.NET Core. Razor Class Libraries.

Chapter 16

ASP.NET Core MVC.

Chapter 17

Using Content Management Systems (Piranha CMS).

Chapter 18

ASP.NET Core Web API. Swagger and Open API. Health checks. WCF and gRPC are mentioned briefly.

Chapter 19

Machine learning with ML.NET.

Chapter 20

Windows Forms apps. Windows Presentation Foundation apps with .NET Core and Windows Compatibility Pack. The XAML Standard. Modern Windows apps.

Chapter 21

Using Xamarin for building cross-platform mobile apps. Calling web services.

Conclusion

As you can see, this is a lot, and goes from the plain C# language to machine learning and Blazor. I’d say that some topics, such as Content Management Systems, could have been dropped, but other than that, pretty much everything that a developer longing to learn .NET could wish for is here. A great deal of ASP.NET Core, which is good, as it is for sure the strong part of .NET Core. So, if you’re one such developer, this is one book that you may want to get, you won’t feel disappointed! Definitely a good value for money!

Now Reading: C# 8.0 and .NET Core 3.0 – Modern Cross-Platform Development – Fourth Edition

Update: see the review here.

I am now reading C# 8.0 and .NET Core 3.0 – Modern Cross-Platform Development – Fourth Edition, by Mark J. Price, from Packt Publishing. Expect a review from it very soon.

C# 8.0 and .NET Core 3.0 - Modern Cross-Platform Development - Fourth Edition

@MarkJPrice @RavitJain @PacktPub

Succinctly Series Readers Awards

image

My e-book Entity Framework Core Succinctly was silver winner on the Succinctly Series Readers Awards!

Many thanks to all who voted for it! And congratulations to Joseph D. Booth for winning the gold award for his Natural Language Processing Succinctly and to Alessando Del Sole (@progalex) for his bronze award for Xamarin.Forms Succinctly!

https://www.syncfusion.com/awards/succinctlyseries/2018succinctlyreadersawards

Entity Framework Core Cookbook – Second Edition

Some of you may be aware that my new book for Packt Publishing is out! It is titled Entity Framework Core Cookbook – Second Edition because it was meant to be the second edition of Entity Framework 4.1: Expert’s Cookbook. In fact, it is mostly a full rewrite.

It is organized in chapters:

Chapter 1: Improving Entity Framework in the Real World

Chapter 2: Mapping Entities

Chapter 3: Validation and Changes

Chapter 4: Transactions and Concurrency Control

Chapter 5: Querying

Chapter 6: Advanced Scenarios

Chapter 7: Performance and Scalability

Appendix: Pitfalls

When I started writing it, .NET Core was still in early RC1. Things changed a lot from RC1 to RC2 and then again to RTM, so I had to revisit all chapters in the end. It was a pity that EF Core 1.1 was released shortly after the book was closed, because I could have talked about it too. Also, there are things that I could have covered, like extending Entity Framework Core, but there were so many of them! Smile Maybe in a future time!

Those of you who are interested can get a copy from the Pack Publishing site or from other sellers, either as an e-book or in hardcopy.

I want to thank everyone at Packt Publishing, namely Chaitanya Nair, Merint Mathew and Siddhi Chavan for their professionalism and support!

Machine Learning Week – Packt Publishing

MLW2016-banner

The good guys at Packt Publishing are at it again!

Packt Publishing is celebrating the Machine Learning Week. Machine Learning Week runs from Monday 18th January until 23:59 GMT on Monday 25th – throughout one will be able to save 50% on some of the most popular titles – such as Python, Java .NET and many more. Also, with a 50% discount on top titles, one can also pick up a 5-eBook bundle for just $50. Checkout link http://bit.ly/209h0lv!

Blend for Visual Studio 2012 by Example: Beginner’s Guide Discount Offer

I recently published a review of Pack Publishing’s new book, Blend for Visual Studio 2012 by Example – Beginner’s Guide. Well, guess what, Pack is offering a 50% off discount if you buy it between 17th and 25th of September! You just need to use this discount code:

Banner

Keep in mind that this code is only valid for this ebook!

So, what are you waiting for? Winking smile

Blend for Visual Studio 2012 by Example Review

Introduction

I was recently asked by Packt Publishing to review another of their books. This time it was Blend for Visual Studio 2012 by Example, a book by Abhishek Shukla (@abbeyshukla), apparently, the first book on Blend for Visual Studio, even if it still covers Visual Studio 2012, most of it will apply to 2013 as well. My interest in Blend came from the fact that I recently had to work with Silverlight, and Blend is, of course, one of the must-have tools.

This book is for beginners on Blend, and it covers a number of technologies around XAML:

  • Windows Presentation Foundation (WPF)
  • Silverlight
  • Windows Phone
  • Windows Store

Each chapter starts by explaining some concept and then goes on to a sample application that demonstrates it.

Chapter 1 – Getting Started with Blend

So, the first chapter is just an introduction on what Blend is used for, how to get it and install it, the Blend IDE, etc. We are guided through a sample (and simple) application built in Silverlight. I’d say it’s a decent start.

Chapter 2 – Layout Panels

The second chapter talks about one of the fundamental building blocks in any graphical application: the layout components. We are presented the five basic layout panels existing in WPF (Grid, Canvas, Stack Panel, Wrap Panel and Dock Panel) and given one example of its usage (except Wrap Panel and Dock Panel). Others, like Border, Popup, Scroll Viewer, Uniform Grid and View Box are also just succinctly described.

Chapter 3 – Working with XAML

This one is about the Extensible Markup Language (XAML), the glue that brings together WPF, Silverlight, Windows Phone and Windows Store apps. We are taught about namespaces and custom registrations, the XAML syntax, and how XAML relates to C#. We also learn about styles, a very important concept.

Chapter 4 – Styles and Templates

In this chapter, we have more styles and also templates and resources, three concepts closely intermingled. We learn about the several levels on which resources can be declared and the difference between static and dynamic resource references. Then, style definitions, targeting and inheritance and how to use resource dictionaries to skin our applications. Templates come next, in its two major flavors (control and data). We see how we can edit the templates of existing controls

Chapter 5 – Behaviors and States in Blend

This time its all about adding interactivity to applications, through behaviors and visual states. We learn about Blend’s own behavior library, that can be used for both WPF and Silverlight, and get to create a sample animation. Next come visual states, the default XAML mechanism that is supported natively by both Silverlight and XAML, and we also learn how to do a similar animation effect.

Chapter 6 – Understanding Animation and Storyboards

In chapter 6 we go more deeply into animations using the IDE’s powerful storyboard tools. We learn how to record, edit and play an animation built exclusively using these tools and how it gets translated to XAML.

Chapter 7 – Understanding Databinding

Another of the major concepts in XAML is databinding, the subject for this next chapter. We are taught about dependency and attached properties, databinding modes and directions, how to load data from either XML files or our own classes and to bind it to controls. One thing that I think should be here is value converters.

Chapter 8 – Vector Graphics

This chapter talks about the graphic shapes of XAML. We learn how to import existing vector files into XAML and how to create custom shapes.

Chapter 9 – User Controls and Custom Controls

Another hot topic is reusable controls, of the two basic types: user controls and custom controls. We learn about the difference between the two, what they are used for, and create one sample of each.

Chapter 10 – Creating Windows Phone Apps

This chapter is totally dedicated to building Windows Phone 8 apps. It explains the different types of projects, device sizes and resolutions and introduces the Windows Phone Emulator. Then it talks about the requirements that need to be met in order to submit an app to the Windows Store, and how can we test its compliance. Note that only the user interface is covered, not more advanced features of Windows Phone, like sensors, etc.

Chapter 11 – Creating Windows 8 Store Apps

The final chapter is about building Windows Store Apps. We learn about the different kinds of apps available, how to certify and submit our app to the store.

Conclusion

Like I said, it is a book for beginners, without any knowledge of XAML, and from this perspective, I think it does a decent job. It wouldn’t be possible to cover everything , but some important topics received a fair treatment.