Best products from r/dotnet

We found 70 comments on r/dotnet discussing the most recommended products. We ran sentiment analysis on each of these comments to determine how redditors feel about different products. We found 83 products and ranked them based on the amount of positive reactions they received. Here are the top 20.

Top comments mentioning products on r/dotnet:

u/anondevel0per · 5 pointsr/dotnet
  1. Yes, it is. Make sure you understand MVC which is quite similar. Model - View - Controller. MVC is essentially the future of ASP.Net application development. If you wish, you can delve into WebForms but it's effectively a dying technology (and good riddance)

  2. I'd look at the following, they are pretty heravy so do take breaks, here and here. There are TONS of blog posts about ASP.Net security best practices, salting passwords, encryption etc.

  3. The majority of .Net job offerings use ASP.Net in some capacity. The definitions of certain components will confuse you (Web API, MVC, WebForms, SignalR, I could go on...). It's WELL worth understanding this stack as you know, "The Internet is the future". I would recommend Steve Sanderson's book on MVC, it's not heavy and it actually goes through an application start to finish.

  4. Most certainly, to be a modern developer and open to many career opportunities you will need to know JavaScript pretty well. Code School is fun and easy to use. It will teach you some quirks of JavaScript that you'll need to know. Always be aware that JQuery is not JavaScript. JQuery is an often used library.

  5. Github is the best place for collaboration but you'll have to learn how to use Git (or use Windows Git or whatever the weird wrapper is called). Git and source control in general is important but might not be necessary to learn yet.

    My biggest piece of advice is to concentrate at one thing at a time, don't think "I have a great idea here for a web application, urgh, but what about security, what about scaling it!?" at your level, those problems are non-existent for you. Get the basic app running anywhere, then run through, security, scaling, testing, one thing at a time. It's only when you get to a senior level do you have to consider multiple things at one time and at the start of a project.

    Just remember, once you learn a language, it's behavior, it's syntax that's all that matters really. For every language. Frameworks and methodologies are easily learnt. The best thing is, once you learn one language, learning another becomes easier every time because most languages (like in the real world) have similar structures and syntax.

    Don't ever give up.

    As a sidenote, it's a good career to go down, I am mid-twenties and I earn more than both my parents combined and I am effectively my own boss, choose my own hours, wear what I want.
u/Krom2040 · 3 pointsr/dotnet

“Why is C# better than Python” is a tough question to answer, but the short answer is that all the features of C# were put there for a reason. And there are MANY features; C# has evolved over the years to support virtually all of the programming paradigms you can imagine, from procedural code to object-oriented to functional to low-level memory/hardware interaction to whatever. It’s dauntingly complex to dig into all of it, but you really only need a relatively shallow subset of those features to be productive, and you’ll only get better as you absorb more of the profile. What you find as you watch other languages like Python evolve is that they’re really playing catch-up, trying to patch in features that C# has had from its inception. Of course, trying to stick static type safety in after the fact is extremely difficult, but you’re seeing a lot of that in both Python and JavaScript. The lifecycle typically goes something like this: new developers get a whiff of the complexity of C# and are put off, then are pleasantly surprised by how easy and “flexible” JavaScript seems, spend years working with it, and then after hitting a wall with the limitations of those languages, they start down the rabbit hole of trying to monkey around with them to try to fix them up to be more like C#.

Just from the outset, static typing is a huge necessity for large software projects. You can’t afford to exist in an environment where every change of a property throws the stability of your codebase into question, with a host of problems that you can’t identify until runtime. Code clarity is, I would argue, the DEFINING feature of a stable, healthy project, and what you find with dynamically-typed languages is that people get to be afraid to refactor for clarity, because the code is brittle and can’t be changed with any reasonable
level of confidence.

Som people try to make assertions like “a good linter is just as powerful as a strongly-typed language”, but that just strikes me as nonsense. It’s only true if you can commit to using the language in a very basic, highly-conventional way, and once you’ve done that, what you’ve REALLY done is abandoned the flexibility that was the hallmark of the loosely-typed language in the first place, AND what you end up with is a very limited subset of the features a true statically-typed language gives you. It’s really tantamount to believing that most static-typing support is superfluous, which it is most definitely is not.

The thing about JavaScript in particular is that it received an enormous boost by being the only game in town. It’s still a pretty crappy language, but it used to be considerably worse; people tolerated it because it was the only game in town. Even then, it had its cadre of language evangelists who assured everybody that the overwhelmingly primitive nature of the language was really a great feature, and maybe in some abstract sense they were correct insofar as it was sufficient to become a building block for better transpiled iterations of it. But largely, as new features were introduced, developers embraced them wholeheartedly, which likely wouldn’t have been the case if there really was a ton of value in the extremely raw nature of early JavaScript.

These are a couple of really excellent resources for C#, which really dig into the design motivations of the language:

https://www.amazon.com/C-Depth-3rd-Jon-Skeet/dp/161729134X
https://www.amazon.com/C-7-0-Nutshell-Definitive-Reference/dp/1491987650

It’s worth noting that they’re both enormous books, and ironically the “Nutshell” book is over a thousand pages! That’s the kind of scope that you’re dealing with to really get into what C# has to offer. But once you do, it can feel awkward to switch between that and less-powerful languages. For that reason, I think every developer in any language could stand to learn about C#, since it’s just a great case study in language design.

All of that said, I always think it’s important to remember that programming in most dynamically-typed languages is pretty much like writing every C# program using Dictionary(string, object) as your only data type.

u/JustMakeShitUp · 1 pointr/dotnet

Going to grab a few things from some of your comments and pitch in some advice. I hope this comes across as earnestly as I mean it.

> I will never quit next time.

I'm going to suggest a slight change to this. The problem isn't that you quit. It's when you quit. It's okay to quit if your job dead-ends. Please don't feel that this isn't an option. I know a COBOL programmer who learned that the hard way after being downsized from a decade-long job, and spent years unemployed. There are also several studies that suggest looking for a new software job every 1.5-2.5 years just to get a pay increase from your new qualifications, since it's hard to get it at the same job. And there are cases where you tell your boss that there's nothing new left to learn at your job and you need a chance to grow and he just shoots you down. But you didn't give it time to dead-end. It'd be understandable if you had something better waiting, but...

>My friends and family thought I overreacted and the company was bound to create new products eventually, the thing is the commute was long and when I came home with massive pounding headache for riding public transportation , I didn't have the energy to work on my side projects or learning ASP.net.

Valid concerns. Was your commute much longer than an hour? I've had hour commutes from two-bus trips with 15 minute layovers. It was not awesome. But you get some comfortable headphones, take a book, and learn to enjoy it. public transportation takes longer than driving, but you're also not dealing with traffic and having people cut you off. Even telecommuting has its downsides. It's hard to find a job that's all roses. You have to learn a positive outlook as much as your job skills, and eventually you pick your favorite compromises when you've seen the alternatives.

Also, ASP.NET isn't rocket science. There are new/advanced techniques in it (MVC, Razor, etc), as with anything. But having basic .NET experience for a junior is more than enough. Sometimes it's just as valuable to pick up a new guy without any bad habits as it is to hire someone with experience. ASP.NET has evolved significantly enough that I'd check how modern those skills are before hiring based on them, anyway. You'll find it an unfortunate reality that few employers want to invest in training a new person. That's why the first jobs tend to underpay and underwhelm.

> I accepted the offer not because the need of money ... but because of social pressure to get a job, any job.

Agreed that this was not a good idea. Did you also consider that, when you quit, you quit because of someone else's perception of the value of your job? It's still peer pressure, and you're also operating under pressure to get a job that you feel fits your self image. And now you've submitted to the external influence here. You haven't left the external influence - you've just picked the advice that you thought was more valid. External influence isn't bad - everyone who has given you advice has done it in your "best interests". But if others are the sole reason for your decisions, you're always going to be unhappy.

Might I suggest that you consider that work is just work? We don't do it for fulfillment - we do it to pay the bills. It's a means to an end. You're looking for the best-paying, highest-growth, least-stress position you can find. One where you can work hard and then leave work at work to go home and live. Don't get caught up in living your employer's dream on your own time.

> Through his connection and network he bought the source code of two different softwares, which he sells on the side. My job was simply to maintain the softwares.

There's a decent chance that, given no external input, he wouldn't make anything new. However, that doesn't mean you wouldn't get the chance to make new things. In jobs like that, I've built maintenance tools for easier install/support, I've refactored things into a cleaner base, I've practiced new implementation/deployment technologies in branches, migrated old codebases to Git, etc. I've even made product enhancements and suggestions as I got more familiar with the business needs. Even if the owner didn't have any vision (which is pretty common), it doesn't mean that he's utterly blind. Just ignorant.

Not only that, but if your task is just maintenance, you could have kept a steady progress on fixing those bugs while learning on the job. You could have been learning not only code skills, but valuable employee skills like contract negotiation, and how to manage your boss. Seeing the bottom of the barrel does wonders for your career motivation, if you need it.

And you could have been scheduling interviews the entire time at new places while building your resume. Pro-tip: don't put this job on your resume. Quitting your first job after 20 days doesn't give a prospective employer a good impression. Working for 6 months and catching a more exciting job is understandable. Or jumping ship once you've got a better job.

> the only tasks I was given were fixing bugs.

> I realize that I always have to fix bugs as junior

Sometimes this isn't just about giving the shitty job to the junior. Some times it's about giving them a low-pressure way to get familiar with the code base while still being productive. I let a junior write some new functionality in a 20 KLOC-ish project. That was in a branch that eventually made it into production for one customer. Unfortunately, he changed a lot of the base classes despite all my ominous predictions, and I was too busy putting out fires to stop it before it got too far. Soon it was 100 commits behind master and I had to merge it myself to be sure that it didn't break functionality for the other 40 installations using that code. Some lessons have to be learned the hard way for everyone, and fixing a feature has less risk than adding one. Especially on a new codebase.

Maintenance might not be the most glorious thing, but it's something everyone needs to know how to do. Write-only coders aren't as popular as they think they are. Being able to deal with an existing codebase and refactor/repair without breaking it is an extremely valuable skill in a team. Honestly, you'd probably be hating and rewriting your code regularly at any job, even if it was brand new. It's just something about coders that we always feel like the job's never done.

Not only that, but there are consultants who base their entire careers around being able to walk into a terrible codebase and clean it up. It's a basic skill, not a lesser skill. And there's an art to it beyond the function.

> What done is done, but did I really over react

I don't want you to feel like your concerns weren't valid, because they were. It was an overreaction to a legitimate concern, not a completely wrong reaction. There's just maybe a bit more to the picture that you'll learn with experience, which will teach you how to weigh those concerns. If you have a tendency to overreact or let people push you into bad decisions, find a friend who can help calm you down and analyze without pushing you into something. And then don't jump into a decision without their advice.

u/Manitcor · 14 pointsr/dotnet

There are some key concepts you want to get down if you really want to make the most of .NET

  • OO design and basic patterns
    Design patterns are used over and over again in OO based systems. A good understanding of what they are for, and how they tend to be used will be helpful when trying to understand key framework extensions and 3d party libraries. I like to point people at Head First Design Patterns. The opinions on design patterns in this book are a bit dated and the examples use Java syntax but they are all relevant to the .NET world and will go a long way to understanding how class names and object structures are used in OO systems.

    IMO One of the biggest concepts you'll need to understand in OO currently is the Inversion of Control pattern (also referred to as dependency injection) and the frameworks that provide it. Most modern .NET applications leverage some kind of dependency injection to simplify development and make unit testing and porting of classes easier.

    NOTE: I understand many folks in the PHP world feel that PHP is a full OO system. While they have made strides in this area it is not a fully typed OO system. It's a procedural system twisted to provide some OO features.

  • Syntax
    This is easy, just review MSDN docs and samples. The biggest different you will see in the .NET world is a different opinion in general on casing of object and method names.

  • Frameworks
    This is the part that seems the most overwhelming IMO. The language itself is fairly easy but understanding the huge amount of 1st and 3rd party libraries, frameworks and tools can be daunting. Since you come from the PHP world I am going to assume you are most interested in web based applications. What I would recommend is to pick a set of tools for your web stack and learn them. Once you understand the key pieces of a web application and how they interact you can start picking and choosing different components to meet your needs. I am going to suggest you start with the following stack to get started with a web application, this is the same stack I use for most of my clients making smaller functional websites or simple content driven systems.

  • .NET 4 (you can do 3.5 but really just go with the latest)
  • Core Web App - MVC (3 or 4)
  • Dependency Injection - Unity 2.0 or 2.1
  • Data access - Entity Framework
  • Application Security - .NET Membership Provider (there is a newer slightly better framework by MS but I cannot recall the name at the moment)
  • Consuming 3rd party services - WCF
  • Exposing your own services REST - MVC (since you are already using it for pages)
  • Exposing your own services using multiple protocols/data formats - WCF
  • XML Processing - Linq and Lambda's. Also be aware of XmlTextReader and XmlTextWriter for targeted high speed forward-only processing.
  • Configuration management - build in web.config with CSD for complex configuration structures beyond what appsettings can provide.

    Key Concepts for Modern .NET Apps

  • Generics
  • Lambdas
  • Linq
  • Closures
  • dynamic typing
  • threading

    Some basic tools to help you:

  • dotpeak - provides detailed assembly information and some decompilation.
  • Assembly binding log viewer - helps troubleshoot dependencies by logging internal CLR calls to dependent libraries.
  • MSBuild - Build management and orchrstarion. This is the system used internally by Visual Studio for building projects. It's a command line tool so you can build projects even without visual studio. A basic understanding of MSBuild makes it fairly easy to use any IDE or text editor you like for .NET development. I do however like VS2010 or 2012 as it goes a long way in helping you code and understand .net.

    Edit: Now with more links.
u/ThereKanBOnly1 · 35 pointsr/dotnet

Literally every part about this sounds like an up hill battle. Frankly, no matter what the course of action, a year isn't going to be enough. You've got to start tempering expectations with that now.

The challenge here is rewriting all that Web Forms logic, and this is the piece that is the biggest hurdle. I assume, that since you are working with web forms you don't have any test suite in place, so you're basically walking a tightrope without a net. I also assume that the actual business logic of the application is probably closely intertwined with web forms as well (which I'm assuming because that's how its been nearly every web forms app I've worked with).

Before you start wondering with MVC is the right fit for you, you've got to prepare your code base from moving out of Web Forms. You should pick up Refactoring by Martin Fowler. And begin to move as much code as you can out of code behind files, and into pure C# classes that you can test. Interfaces are your friend. Facades and Adapters are your friend. Unit tests are your friend. You need to have your business logic as portable as possible in order to move away from Web Forms and not be constantly chasing down bugs and unexpected functionality. The more your code-behind is a facade that just takes inputs and calls other classes with them, the better off you'll be

With that out of the way, now we can get in the framework discussion. First off, I don't think a SPA is a good approach here. It'll be too heavy of a lift for your team, and probably not worth the time and effort at this point in time. So you're pretty much left with MVC as an architecture, which is fine, but I think you're going to have some issues with "vanilla" MVC considering the load and the users you're going to have to service, so you're going to have to look beyond that to make this work.

One of the key components to scaling this will be a good cache. If every read needs to hit the database, then you're done. I would recommend using Redis for caching, but an in-memory cache will help you here as well.

I would also strongly recommend looking into CQRS. That stands for Command Query Responsibility Segregation. The high level idea is that requests that need to modify data gets handled by different classes than reading data. This makes it much easier to scale up/out the read side, and also makes it much easier to know when the cache on the write side can be invalidated (since that's coming from the read side).

The challenge with ramping up on CQRS is that its generally presented with a lot of other solutions; MongoDb/Document databases, Event Sourcing, event messaging. Those are good and interesting in their own right, but they are way more than you need right now and CQRS does not require using them.

The last thing I'll touch on here is that if you've got one big ball of mud, you're path to upgrading this going to be very tough. If you can find isolated parts of the application to split off, and test in a different framework, then you'll be much better off. The more isolated sales is from inventory (or whatever you have) the better off you're going to be in the long run. If you can find the time to isolate those components in the application now, rather than try and rewrite the big ball of mud, your future self will thank you.

u/sirdoctoresquire · 2 pointsr/dotnet

So, this post is close to a week old. I hope I'm not too late.

Microsoft actually has some pretty good training courses that you can go through for free.

C# Jumpstart

ASP.NET Jumpstart

I used the jumpstarts as a refresher a while ago after I got stuck developing on Oracle for a while and they are both good overviews.

That said, when you are looking at doing MVC .NET development you are really talking about three things. Learning C#, learning about the .NET framework, and learning how to develop in Microsoft's implementation of the MVC framework. I would learn in that order.

Since you have experience with Java, C# should be fairly familiar to you. I'd still recommend skimming over the basic differences. Once you've got that in hand, it is good to learn about the basic offerings of the .NET frame work. I've found that C# 5 in a Nutshell does a great job at going over both C# and the .NET frame work. It is dry, but worth going over. Once you've been through the first few chapters, you can pick and choose where you want to dive in next. IMO, LINQ is great.

Then, once you've got a good grasp for C# and the underlying framework, it is pretty easy to tack the MVC model on to it. The biggest problem I've seen is devs trying to learn every thing all at once. Depending on your experience level, you may be able to dig right in. Best of luck.

u/CaRDiaK · 2 pointsr/dotnet

Working in Legacy one of the areas you can make an impact on a system. Bar none. You can pretty much refactor until your hearts content, you can make wrappers to old calls in new fancy ways, cook up solutions to problems you've identified and present these to your colleagues. Because that's what good developers do..

It's rare you get to work on exactly what you want to all the time in this game.

So what are your alternatives now?

To be honest I do think you have made a mistake. But an important one. If you learn from it, then that's all good and you shouldn't worry about it.

Sometimes you'll learn people don't know why things are a good idea or a better option... you've got to steer them and let them think it's them that's making the decision on something great, when really, that was your plan all along.

You know where you get the real money and make the real difference in our game? Working at either end of the spectrum. Either bleeding edge, or with tech so old no one else wants to touch it. If you want the middle ground, the easy predictable stuff then be prepared to not be making much of a difference in your day to day duties. It's just the way the game works.

Suggested reading; The Passionate Programmer;http://www.amazon.com/The-Passionate-Programmer-Remarkable-Development/dp/1934356344

Apprenticeship Patterns; http://chimera.labs.oreilly.com/books/1234000001813/index.html

Best thing to do is put a period in it and move on.
Good luck!

u/jellatin · 4 pointsr/dotnet

You sound exactly like me 10 months ago. I also took the plunge, moving from PHP/MySQL to C#/.NET. Keep in mind that I am not a .NET veteran, but I have gone from knowing nothing to developing all of my sites in it in just under 10 months.

  • Object Oriented is a big part of it. If you know this from Java, great. If not, start there. I recommend Head First Object-Oriented Analysis & Design

  • MVC - if you have used a PHP MVC framework you are going to have a much easier time of it. I did not, so I had to learn MVC, OOP, C#, and .NET all at once.

  • Wrox ASP.NET MVC3 has been invaluable. My copy is covered in sticky notes and highlighter after reading, and I refer to it heavily.

  • I just bought Pro ASP.NET MVC 3 Framework, and it also seems good, however, I like the Wrox book better.

  • Pluralsight.com - A little pricey at $30 / mo, but they have a plethora of extremely high quality videos. If you have enough free time to make use of the monthly subscription, I do recommend it.

  • When you come to databases, I highly recommend going the Entity Framework route. Most other things seem like garbage by comparison in my limited experience.
u/Freonr2 · 2 pointsr/dotnet

Given your understanding of the problem with Js/React, I'd dive right in to C#/.NetCore. You're aware of potential pitfalls and confusion of language vs framework, but there's probably not a lot of avoiding it anyway. C# is fairly straight forward for the most part. .NetCore is fairly dominant now so starting with it makes sense.

You could start with this book if you wanted:

https://www.amazon.com/Programming-Language-Covering-Microsoft-Development/dp/0321741765

Its starting to show some age, but it is where I started. It does do a good job covering stuff like value vs reference types, nulls, basic operators, special types like string, structured exception handling, etc. that could be valuable, but you can probably infer most of it if you have learned any sort of OO before. There's some stuff in there that's simply out of date, and glaringly no coverage of async/await. There are a bunch of newer language features such as string interpolation that may be better or more accepted ways to handle things these days.

edit: this is also popular, but still only up to date on C# 5.0:
https://www.amazon.com/C-Depth-3rd-Jon-Skeet/dp/161729134X

u/ItsAConspiracy · 2 pointsr/dotnet

If you want to minimize your work and just want it running on the new platform, rather than doing a full rewrite:

Use MVC, which is a lot more like classic ASP. Don't use Razor, the new view engine...go with the old one, which uses the same tags as classic asp.

The main difference is that MVC has a "controller" for each page where you can put business logic, populate variables that will display on the page, etc. That way you don't have so much logic mixed in with your html. But it's still possible to have logic in the view, and you can leave it there initially then move it to the controller gradually. You will need to convert your vbscript to a .net language...I prefer c# but vb.net might be an easier conversion.

Data access can work pretty much like you have now...the basic .net stuff isn't that much different. If you're calling stored procedures, just keep them, maybe write a simple wrapper around the data access stuff to abstract away the boilerplate. If the old code builds sql by mashing strings together, make sure you use actual sql parameters, so you're not vulnerable to sql injection attacks.

If on the other hand you're up for a full rewrite and updating the UI to current standards...still use MVC, replace the frames with ajax, and take a look at knockout.js, jquery, and jqueryUI. You'll end up with a much nicer site.

The best MVC book is probably Sanderson's.

u/emcoffey3 · 2 pointsr/dotnet

For a quick reference, I like this list of 101 LINQ samples. For something more extensive, Pro LINQ is a little old but still pretty good. Also, C# in Depth is a great all-around C# book and has a few chapters devoted to LINQ.

I haven't read any real thorough comparisons between LINQ methods and their corresponding SQL keywords, but, most of the important methods are named identically to their SQL counterparts (with a few exceptions like Take() instead of TOP). I tend to stick with the standard method syntax and lambda expressions over query syntax most of the time, although the query syntax is sometimes more readable for groupings.

I use LINQ to Objects all the time, and LINQ to XML has come in handy on more than one occasion. If your intention is to use LINQ as a replacement for ADO.NET (i.e. accessing a relational database), then you'll probably want to look into Entity Framework and LINQ to Entities (the LINQ to SQL approach has been deprecated for a few years). Whether or not you should actually do this is debatable, but that's a whole other conversation.

u/Pinski47 · 1 pointr/dotnet

The Pragmatic Programmer is about the discipline of Software Engineering. It focuses on treating Software Engineering like a craft, just like any other craft. Turning the focus of "just producing code" into an apprenticeship.

Clean Code is about how to write your code as cleanly as possible. Clean Code allows for better productivity, better maintenance, clearer understanding of your code, and makes communication with your peers easier.

Neither book is focused on .NET or any type of specific tech, they are more about how to approach the discipline of Software Engineering. Having that kind of mentality will help you conquer any Software Engineering hurdles you may be having.

If you feel you need to learn more about how .NET/C# works. These books might be best saved for later. But they will come in handy in the long run. It sounds to me like you have a grasp of being able to do your day-to-day job now. So maybe some general knowledge about Software Engineering would help.

If you are looking for something to read that is C# specific I cannot recommend C# in Depth enough. It is a rather dry read, but it completely covers all aspects of the language. It even does it in a chronological way so you can see the language grow and develop over time. If you have ever thought "Why does C# do it that way?" this book will answer that question. I found it fascinating to see the language grow over time and realize why the language is what it is today. Make sure to get the latest version of the book which I believe is currently the 3rd Edition.

u/NickTheFirstOne · 1 pointr/dotnet

Hello,
Based on the comments until now i understand that you trying to learn asp.net core 2.
When i started my journey on asp.net i started with Professional ASP.NET MVC 5 great book.

For Asp.net Core i started with: Pro ASP.NET Core MVC its a nice book for asp.net core 1.

for asp.net core 2 i would suggest the Pro ASP.NET Core MVC 2 but with a slight hesitation because asp.net core 2 at the time of the publishing was still new.

Also this MVA course could help you.

If you need more info and tutorials - courses. Comment bellow and i will try to help you find the best courses for you.


Thanks.

u/tragicshark · 1 pointr/dotnet

I own all of Robert C. Martin's books, except for UML for Java, as well as Martin Fowler's Refactoring (the white one), PEAA, DSL and Analysis Patterns. I also have Refactoring to Patterns, Code Complete and Design Patterns (aka go4) and a few others.

I would suggest Refactoring to Patterns is the one you are looking for, but that expects you have a working knowledge of what the patterns are already (likely with your experience though you may not know them by name). I don't think that is strictly necessary but it will help you understand why you might want do do things the way being suggested in the book. The examples are in Java, but they apply to C# just as much. His site is here: https://industriallogic.com/xp/refactoring/ and he has the code up behind an online course / paywall (I have not looked into this).

In a greenfield environment, tdding up an application from a blank project Uncle Bob or Fowler's pattern books are probably better, but from the perspective of an existing codebase I think Kerievsky's Refactoring to Patterns and Fowler's Refactoring are best.

u/jaymo3141 · 5 pointsr/dotnet

E-commerce is where it's at my man. E-commerce is straight forward. It's a store where you buy stuff. Real simple. However, the backend architecture is a bit more involved. You have to handle things like Databases, Queues, Cacheing, Error Logging, Load balancing, etc. If you want to be a mid-level back end dev you really need to understand the basics of Service-Oriented Architecture (SOA). You should also be familiar with CI/CD Pipelines and docker containers. Try looking into some open source e-commerce platforms:

https://codinginfinite.com/best-dotnet-core-e-commerce-open-source-platforms/

https://github.com/dotnet-architecture/eShopOnContainers

Also you need a strong understanding of Object Oriented Programming (OOP). So you'll need to understand S.O.L.I.D principles very well. Of the SOLID principles, you should focus heavily on the 'D' which stands for Dependency Inversion.

Lastly, in any decent back-end interview, they'll ask you about design patterns. I'd recommend "Head First Design Patterns" (https://www.amazon.com/Head-First-Design-Patterns-Brain-Friendly/dp/0596007124/ref=sr_1_1?crid=3JOAGN3VIZZ8P&keywords=head+first+design+patterns&qid=1574177751&sprefix=head+first%2Caps%2C187&sr=8-1 )

Hope that helps!

u/fokov · 1 pointr/dotnet

If you are interested, CLR via C# will provide one with a metric fuck-ton of trivia on how it really works. I read the 2nd edition about 7+ years ago, but most of the really trivial stuff fell out of my head. However, a lot of that knowledge isn't needed to actually build a working product.

One reason I like out params is the patterns similiar to bool TryParse(string text, out T value). This way a single if statement can shorten code up considerably if I need to write other conditions limiting the value to perform default or special case logic. The more I can reduce boilerplate/noisy code the better IMO.

u/TheManFromOregon · 1 pointr/dotnet

I'm currently learning MVC as well, and I went with the just-released Professional ASP.NET MVC 5 [1].

Reading the Amazon reviews, the Freeman book uses dependency injection via the open source library Ninject. That may be a common development approach for all I know, but I wanted to focus on learning MVC without any third party library requirements.

If anyone has thoughts on Freeman's approach, I'd be interested.

If you like video tutorials, another resource is a MVC 4 video tutorial offered free by Pluralsight. [2] They have subscription plan that looks reasonably priced, and it covers MVC 5. (The Pluralsight videos are narrated by K. Scott Allen, who is also one of the co-authors of the Galloway book.)

[1] http://www.amazon.com/Professional-ASP-NET-MVC-Jon-Galloway/dp/1118794753/ref=pd_cp_b_0

[2] http://pluralsight.com/training/Player?author=scott-allen&name=mvc4-building-m1-intro&mode=live&clip=0&course=mvc4-building

u/phuber · 2 pointsr/dotnet

If you are open to it, here are a few good reads to help you on your way. The legacy code book may pay dividends quicker given your situation.

Clean Code: https://www.amazon.com/dp/0132350882/ref=cm_sw_r_cp_apa_ruhyybGGV0C34

Refactoring: Improving the Design of Existing Code https://www.amazon.com/dp/0201485672/ref=cm_sw_r_cp_apa_gwhyyb1VRNSKK

Working Effectively with Legacy Code https://www.amazon.com/dp/0131177052/ref=cm_sw_r_cp_apa_0whyyb3Y604NJ

Continuous Delivery: Reliable Software Releases through Build, Test, and Deployment Automation (Addison-Wesley Signature Series (Fowler)) https://www.amazon.com/dp/0321601912/ref=cm_sw_r_cp_apa_JxhyybA08ZQF8

u/Octopork · 2 pointsr/dotnet

Been down this road and finally started having it make sense a couple of months ago. Try as i did to be better at testing it always felt like a hassle until i shifted my focus to writing testable code.

With that in mind, aside from covering basics of writing tests:

  • SOLID principles, hopefully you know these already(or of them) but if not, read into them. I found i had to start thinking about them while programming for the ideas to click.
  • Inversion of control and DI, I highly recommend Dependency injection in .Net core. Properly following these ideals makes your code so much easier to test and refactor.
  • You don't need to learn all there is about functional programming immediately but at least understand functional purity, pure functions are fairly painless to test.

    Injecting an interface that does nothing but provide DateTime.Now seemed absurd and overly complex when i first read about it but once all those pieces came together everything finally clicked and i no longer hesitated on writing tests as they were no longer difficult to write.

    I've been meaning to read through Working Effectively with legacy code but from what i have read so far it seems to have a huge focus on making old code testable, perhaps an option if your looking at improving your code base in your current job.
u/_InternetGuy · 2 pointsr/dotnet

It does seem like MVC > WebForms. I'm trying to get better at it by following this book http://www.amazon.com/Professional-ASP-NET-MVC-Jon-Galloway/dp/1118794753/ref=pd_cp_b_0 . But I feel like it assumes you know WebForms or previous MVC's to be able to follow it. Do you have any advice where I could start as a beginner approach? Thanks

u/PatrickMorris · 2 pointsr/dotnet

The Head First series is really good, I learned C# using this book. It is focused on GUI programming though, if you are looking for web stuff then you would probably be better with something else.

Head First C#

u/swhite1987 · 4 pointsr/dotnet

I just picked up Pro ASP.NET MVC 5 by Adam Freeman. I'm a chapter or two in, so far so good. It's the currently the best selling ASP.NET book on Amazon.

http://www.amazon.com/Pro-ASP-NET-Experts-Voice-ASP-Net/dp/1430265299

u/JacksUnkemptColon · 1 pointr/dotnet

Perhaps not what you're looking for as this isn't an internet source, but I found the sections in C# 5.0 in a Nutshell on concurrent programming were especially good at explaining this stuff to a non-genius like myself.

u/ssentrep · 2 pointsr/dotnet

Read ‘Code Complete’. IMHO still the single best book on software development. It’s free of BS and buzzwords, and backs all its assertions with citations to actual research, rather than blathering about the author’s opinions.

u/NecroSyphilis · 9 pointsr/dotnet

initially i would avoid learning webforms, have a go at asp.net mvc, this book is how i learnt, its a gentle introduction but you will need to do more to get a deeper understanding, particularly if you need to learn how to interact with a database.

http://www.amazon.com/Pro-ASP-NET-MVC-Adam-Freeman/dp/1430242361/ref=sr_1_1?ie=UTF8&qid=1377855287&sr=8-1&keywords=asp.net+mvc

edit: seems this edition is no good anymore, the edition where they build the sports store application for learning mvc2 was really good but its out dated now.

u/Silound · 1 pointr/dotnet

I find more often than not that patterns are rarely well represented in books; they are almost always delve too far into implementation specific details or simply gloss over any implementation details in favor of theory. Sometimes, all I want is an ELI5 about the pattern, and let me work the rest out for my codebase.

Books on principles of coding, however, are dime a dozen. One I like in particular is Adaptive Code via C#. It gives plenty of code examples (you can download the entire working solution projects from the website given in the book) and it does a fair job of covering several patters and gives specific examples of how they apply to the SOLID principles.

Of course, there's always Design Patterns: Elements of Reusable Object-Oriented Software. This book has been one of the programmer's bibles for the past 20 years. It is a more difficult read, since it is a more theory oriented book. One thing to note is that some of the design patterns discussed in the book have been rendered obsolete by aspects of some languages and frameworks, while a number of new patterns have come to exist based on those same languages and frameworks.

u/ctrlShiftBryan · 1 pointr/dotnet

What I like to do is start with just one class and one method.

As that method grows to more than 5 or so lines of code, start re-factoring it by grouping lines of code together and moving them to separate methods.

As this class grows to 5
or more methods groups the methods in a way that makes sense and move those to separate classes.

I prefer this approach compared to trying to decide all the classes and methods you need upfront.

*This number can actually be smaller or even 2.

I would strongly recommend you read this book:
http://www.amazon.com/Clean-Code-Handbook-Software-Craftsmanship/dp/0132350882#

u/RooN3y_2 · 1 pointr/dotnet

That book is on my Amazon list but it's a bit too expensive for me at the moment. I will purchase it one day though!

Edit: just seen its not as expensive as I thought! I'll definitely be looking to purchase it next. https://www.amazon.co.uk/dp/020161622X

u/enkafan · 3 pointsr/dotnet

I generally recommend Headfirst C# for those looking for a gentle introduction

u/Insomn · 2 pointsr/dotnet

Think I solved this one on my own (well, actually started using Pro ASP MVC 5 that I bought last week), but wouldn't mind if someone feels like chiming in just to make sure my thinking's right.

The stock OOBE for MVC5, scaffolding controllers w/ EF bindings, is for when you want to get an MVP out ASAP, right? It'll work as is, but there's hella tight coupling between the MVC and EF, very opinionated, and for enterprise-level apps is generally regarded as a terrible idea.

If you want a loose coupling, and just throw everything off to Ninject to resolve you do have to implement the Repository Pattern yourself from the ground up?

u/FriendlyChihuahua · 2 pointsr/dotnet

The Microsoft Exam 70-486 covers .NET core as it relates to ASP.NET MVC/WebApi

https://www.microsoft.com/en-us/learning/exam-70-486.aspx

The books I would suggest to pass that are:

ASP.NET Core Application Development: Building an application in four sprints (Developer Reference) 1st Edition
by James Chambers (Author), David Paquette (Author), Simon Timms (Author)
https://www.amazon.com/ASP-NET-Core-Application-Development-application/dp/1509304061/

This goes over the differences in .NET core related to the middleware, the config changes etc. very well.


The outdated exam ref book is:
Exam Ref 70-486 Developing ASP.NET MVC Web Applications (2nd Edition) Paperback
by Simon Timms,David Paquette James Chambers (Author)
https://www.amazon.com/Exam-70-486-Developing-ASP-NET-Applications/dp/1509300929

This book is out of print but you can get it in the Apple Book store. If you intend to take the test I would definitely read it. Just keep in mind that it is outdated. It has nothing to do with .NET core but the information is structured similar to the exam objectives and a lot has not changed.


Review the changes to the Exam objectives provided by Microsoft for the 70-486 exam.


u/CaptainBlood · 3 pointsr/dotnet

The default recommendation seems to be Adam Freeman's Pro ASP.NET MVC books from APress. It's what I chose and I think it does a great job.

http://www.amazon.com/Pro-ASP-NET-Experts-Voice-ASP-Net/dp/1430265299

u/nemec · 5 pointsr/dotnet

A more appropriate title would be "Some things you'd like to know about the CLR".

CLR via C# is really all you want to know about the CLR.

u/realzequel · 2 pointsr/dotnet

I really like the book from the team itself, mvc 5

u/jimschubert · 1 pointr/dotnet

In addition to these, I also recommend Adaptive Code via C#.

u/sarcasticbaldguy · 3 pointsr/dotnet

I agree - WebForms won't teach you anything useful about how the web works, in fact, it will completely hide it from you.

Get this book, follow along and build the Sports Store app. You won't be an expert when you're done, but you'll have a basic understanding of most of the ASP.Net MVC concepts. http://www.amazon.com/Pro-ASP-NET-Experts-Voice-ASP-Net/dp/1430265299

u/cheesekun · 2 pointsr/dotnet

I agree. 50 dollars can get you a 2000 page reference book. Hell 30 dollars can get you a nutshell book http://www.amazon.com/5-0-Nutshell-The-Definitive-Reference/dp/1449320104/ref=pd_sim_b_1

But with StackOverflow & great MSDN documentation is there a real need for books that gather dust?

u/JonnyRocks · 3 pointsr/dotnet

open source aside - you should read this book

http://www.amazon.com/CLR-via-4th-Developer-Reference/dp/0735667454/ref=sr_1_1?ie=UTF8&qid=1415979190&sr=8-1&keywords=.net+via+c%23

you have some terms mixed up. This book will explain everything .net is under the covers.

u/anonymousbjj · 2 pointsr/dotnet

If anyone is interested in exploring this, the CLR does a lot more than just compile VB and C# to native code. Here is a book that will show you much more: http://www.amazon.com/CLR-via-Edition-Developer-Reference/dp/0735667454

Note: This is not a beginner book.

(EDIT) Technical error.

u/z960849 · 0 pointsr/dotnet

I dont understand you kids these days. If you looking to learn something slightly complex BUY A FUCKING BOOK.

http://www.amazon.com/Professional-ASP-NET-MVC-Jon-Galloway/dp/1118794753

And get your employer to pay for it.