Reddit mentions: The best microsoft net books

We found 110 Reddit comments discussing the best microsoft net books. We ran sentiment analysis on each of these comments to determine how redditors feel about different products. We found 33 products and ranked them based on the amount of positive reactions they received. Here are the top 20.

4. CLR via C# (Developer Reference)

CLR via C# (Developer Reference)
Sentiment score: 5
Number of mentions: 10
▼ Read Reddit mentions

5. F# for Scientists

F# for Scientists
Sentiment score: 2
Number of mentions: 3
▼ Read Reddit mentions

13. Professional C# 4.0 and .NET 4

Professional C# 4.0 and .NET 4
Sentiment score: 1
Number of mentions: 1
▼ Read Reddit mentions

16. Beginning Visual C# 2005

Beginning Visual C# 2005
Sentiment score: 1
Number of mentions: 1
▼ Read Reddit mentions

17. ASP.NET Core and Angular 2

ASP.NET Core and Angular 2
Sentiment score: 1
Number of mentions: 1
▼ Read Reddit mentions

18. Beginning Visual C# 2010

Beginning Visual C# 2010
Sentiment score: 1
Number of mentions: 4
▼ Read Reddit mentions

20. Begin to Code with C#

Begin to Code with C#
Sentiment score: 1
Number of mentions: 1
▼ Read Reddit mentions

idea-bulb Interested in what Redditors like? Check out our Shuffle feature

Shuffle: random products popular on Reddit

Top Reddit comments about Microsoft .NET:

u/Orthak · 3 pointsr/mylittleandysonic1

Unity is the bee's knees.
I've been messing with it casually for several years, and got serious in the last 2-ish years. I like it because I get to use C#, and that's the language I know best. Only problem in it's using some weird limbo version of .NET 2, that's not actually 2.0 but is also 3.0 is some places? I think it's because it's using Mono 2.0, which is some subset of .NET. It's weird. They're moving to 4.5 soon anyways so I'm hype for that. I'ts been a lot of fun regardless, I get to apply a different knowledge and tool set from my day job. Not to mention it feels great when you actually get something to build and actually work.

So anyways here's a list of resources I've found over the years to be super helpful:

Things on Reddit

u/jdh30 · 4 pointsr/fsharp

> My other question is if F# good for some scientific applications?

Yes. I started out using F# for such things. I ended up writing the book on it.

F#'s ML core is extremely simple. I think you would find it very easy to learn. Let me get you started:

There is a type called unit that has a single value in it called () that can be used to convey no information, a bit like void in other languages but you can use the value () of the type unit anywhere.

The bool type has values true and false.

Integers are written 1, 2, 3 and so on. Integer arithmetic is 1+2*3. The int function converts a value (e.g. float or string) into an int.

Floating point numbers are written 1.2, 2.3, 3.4 and so on. Floating point arithmetic is written 1.2+2.3*3.4. The float function converts a value (e.g. int or string) to a float.

Characters are of the type char and are written 'a'. Strings are of the type string and are written "foo". You can append strings with "foo"+"bar". The string function tries to convert a value of another type (e.g. int or float) into a string.

Lists are written [1;2;3]. You can prepend onto the front in constant time with 1::[2;3].

Arrays are written [|1;2;3|]. You can read and write elements with random access in constant time with arr.[i] and arr.[i] <- 3.

ML has sum types and product types. The simplest product type is the tuple. Tuples are written (2, 3) and (2, 3, 4). The types of those tuples are written int * int and int * int * int. Tuples can have as many elements as you like (greater than one, of course). Note F# uses OCaml-style syntax which lets you drop many brackets when dealing with tuples, so you can often just write 1, 2.

F# also has record types which are product types where the fields have names. Record types are defined as type MyRecord = {FirstName: string; LastName: string}. Values of record types are written {FirstName="Jon"; LastName="Harrop"}. Given a value r you can get a field with the syntax r.FirstName. As a product type, a value of type MyRecord must have a FirstName and a LastName.

Algebraic datatypes (ADTs) are a combination of sum types and product types. A sum type allows a value to be one of several different options. The simplest example is to define your own boolean:

type MyBoolean = True | False

The values True and False are then values of the type MyBoolean. Like an enum in other languages. But the really cool thing about ADTs in MLs is that those union cases can have an argument of any type you want. For example, we can define an ADT:

type Glyph =
| Digit of int
| Letter of char

The values Digit 3 and Letter 'x' are values of this type Glyph.

The value () of type unit was a minor diversion from other programming languages. Now comes the first major diversion: pattern matching is the only way to destructure ADTs. So the only way to extract those values 3 and 'x' from the value of type Glyph is using pattern matching. In ML there are patterns all over the place. The most obvious place you see patterns in on the left hand side of the -> in each match case of a match expression. Here is a pattern match that will keep digits the same but redact all letters to 'x':

match Digit 3 with
| Digit n -> Digit n
| Letter c -> Letter 'x'

In this case the Digit n and Letter c are patterns. In particular, these have the effect of binding the variable n to the value conveyed in the Digit case (so it can be used on the right hand side of that match expression) or c to the value conveyed in the Letter case.

You can match int, float, char, string and other types such as tuples, records and ADTs using the same literal syntax that you do in expressions.

When you need to match a value but you don't care about its value you can use _ to match any value of any type and not bind it to any variable name.

If you want your pattern to match either something or something else you can write an or-pattern: patt1 | patt2.

If you want to name part of a value that you're matching you can use patt as myVar to call it myVar. For example, we could have written:

match Digit 3 with
| Digit as glyph -> glyph
| Letter c -> Letter 'x'

You can define variables with let:

let x = 3

This looks mundane but that x is actually a pattern so you can also do:

let (x, (y, z)) = (1, (2, 3))

to destructure the int * (int * int) pair on the right and define x, y and z.

You can also define functions with let:

let redact glyph =
match glyph with
| Digit
-> glyph
| Letter c -> Letter 'x'

In ML, function application is written f x rather than f(x), e.g. redact (Digit 3).

Here we come to our second massive departure from conventional languages: when you have tuples you don't need multi-argument functions so every function in ML accepts one argument and returns one value! Furthermore, like OCaml, F# typically writes functions in Curried form. So a function to add two numbers is written let add x y = x+y which has the type int -> int -> int rather than int * int -> int so this is a function that takes x and returns another function that takes y and returns x+y.

Oh look, you've learned enough F# to understand this computer algebra system that can differentiate any symbolic mathematical expression composed of integers, variables, addition, multiplication, power and logarithm:

type Expr =
| Int of int
| Var of string
| Add of Expr Expr
| Mul of Expr
Expr
| Pow of Expr * Expr
| Ln of Expr

let rec d x e =
match e with
| Var y when x=y -> Int 1
| Int | Var -> Int 0
| Add(f, g) -> Add(d x f, d x g)
| Mul(f, g) -> Add(Mul(f, d x g), Mul(g, d x f))
| Pow(f, g) -> Mul(Pow(f, g), Add(Mul(Mul(g, d x f), Pow(f, Int -1)), Mul(Ln f, d x g)))
| Ln f -> Mul(d x f, Pow(f, Int -1))

For example, the symbolic derivative of x^x computed in F# Interactive (e.g. in Visual Studio) is given as:

> d "x" (Pow(Var "x", Var "x"));;
val it : expr =
Mul
(Pow (Var "x",Var "x"),
Add
(Mul (Mul (Var "x",Int 1),Pow (Var "x",Int -1)),
Mul (Ln (Var "x"),Int 1)))

Probably the next thing to understand is that map f [a;b;c;...] = [f a; f b; f c; ...] and fold f a [b;c;d;...] = f (f (f a b) c) d) .... For example, if you represent 2D coordinates as a pair you can write:

let translate (x0, y0) ps = Array.map (fun (x1, y1) -> x0+x1, y0+y1) ps

To sum a list of integers you can write:

let sum xs = Array.fold (fun x a -> x+a) 0 xs

So given a file containing a list of integers on separate lines you can add them all up with:

Seq.fold (fun total line -> int line + total) 0 (System.IO.File.ReadAllLines @"Data/Numbers.txt")

F# has a handy pipeline operator |> so you can write f x as x |> f instead. For example:

System.IO.File.ReadAllLines @"Data/Numbers.txt"
|> Seq.fold (fun total line -> int line + total) 0

Another mind-blowing thing you'll come to love is purely functional data structures. When you add an element to a list, set or map (dictionary) in F# you get a new collection in O(log n) time but the old collection is still perfectly valid and can be reused.

u/CSMastermind · 4 pointsr/learnprogramming

I've posted this before but I'll repost it here:

Now in terms of the question that you ask in the title - this is what I recommend:

Job Interview Prep


  1. Cracking the Coding Interview: 189 Programming Questions and Solutions
  2. Programming Interviews Exposed: Coding Your Way Through the Interview
  3. Introduction to Algorithms
  4. The Algorithm Design Manual
  5. Effective Java
  6. Concurrent Programming in Java™: Design Principles and Pattern
  7. Modern Operating Systems
  8. Programming Pearls
  9. Discrete Mathematics for Computer Scientists

    Junior Software Engineer Reading List


    Read This First


  10. Pragmatic Thinking and Learning: Refactor Your Wetware

    Fundementals


  11. Code Complete: A Practical Handbook of Software Construction
  12. Software Estimation: Demystifying the Black Art
  13. Software Engineering: A Practitioner's Approach
  14. Refactoring: Improving the Design of Existing Code
  15. Coder to Developer: Tools and Strategies for Delivering Your Software
  16. Perfect Software: And Other Illusions about Testing
  17. Getting Real: The Smarter, Faster, Easier Way to Build a Successful Web Application

    Understanding Professional Software Environments


  18. Agile Software Development: The Cooperative Game
  19. Software Project Survival Guide
  20. The Best Software Writing I: Selected and Introduced by Joel Spolsky
  21. Debugging the Development Process: Practical Strategies for Staying Focused, Hitting Ship Dates, and Building Solid Teams
  22. Rapid Development: Taming Wild Software Schedules
  23. Peopleware: Productive Projects and Teams

    Mentality


  24. Slack: Getting Past Burnout, Busywork, and the Myth of Total Efficiency
  25. Against Method
  26. The Passionate Programmer: Creating a Remarkable Career in Software Development

    History


  27. The Mythical Man-Month: Essays on Software Engineering
  28. Computing Calamities: Lessons Learned from Products, Projects, and Companies That Failed
  29. The Deadline: A Novel About Project Management

    Mid Level Software Engineer Reading List


    Read This First


  30. Personal Development for Smart People: The Conscious Pursuit of Personal Growth

    Fundementals


  31. The Clean Coder: A Code of Conduct for Professional Programmers
  32. Clean Code: A Handbook of Agile Software Craftsmanship
  33. Solid Code
  34. Code Craft: The Practice of Writing Excellent Code
  35. Software Craftsmanship: The New Imperative
  36. Writing Solid Code

    Software Design


  37. Head First Design Patterns: A Brain-Friendly Guide
  38. Design Patterns: Elements of Reusable Object-Oriented Software
  39. Domain-Driven Design: Tackling Complexity in the Heart of Software
  40. Domain-Driven Design Distilled
  41. Design Patterns Explained: A New Perspective on Object-Oriented Design
  42. Design Patterns in C# - Even though this is specific to C# the pattern can be used in any OO language.
  43. Refactoring to Patterns

    Software Engineering Skill Sets


  44. Building Microservices: Designing Fine-Grained Systems
  45. Software Factories: Assembling Applications with Patterns, Models, Frameworks, and Tools
  46. NoEstimates: How To Measure Project Progress Without Estimating
  47. Object-Oriented Software Construction
  48. The Art of Software Testing
  49. Release It!: Design and Deploy Production-Ready Software
  50. Working Effectively with Legacy Code
  51. Test Driven Development: By Example

    Databases


  52. Database System Concepts
  53. Database Management Systems
  54. Foundation for Object / Relational Databases: The Third Manifesto
  55. Refactoring Databases: Evolutionary Database Design
  56. Data Access Patterns: Database Interactions in Object-Oriented Applications

    User Experience


  57. Don't Make Me Think: A Common Sense Approach to Web Usability
  58. The Design of Everyday Things
  59. Programming Collective Intelligence: Building Smart Web 2.0 Applications
  60. User Interface Design for Programmers
  61. GUI Bloopers 2.0: Common User Interface Design Don'ts and Dos

    Mentality


  62. The Productive Programmer
  63. Extreme Programming Explained: Embrace Change
  64. Coders at Work: Reflections on the Craft of Programming
  65. Facts and Fallacies of Software Engineering

    History


  66. Dreaming in Code: Two Dozen Programmers, Three Years, 4,732 Bugs, and One Quest for Transcendent Software
  67. New Turning Omnibus: 66 Excursions in Computer Science
  68. Hacker's Delight
  69. The Alchemist
  70. Masterminds of Programming: Conversations with the Creators of Major Programming Languages
  71. The Information: A History, A Theory, A Flood

    Specialist Skills


    In spite of the fact that many of these won't apply to your specific job I still recommend reading them for the insight, they'll give you into programming language and technology design.

  72. Peter Norton's Assembly Language Book for the IBM PC
  73. Expert C Programming: Deep C Secrets
  74. Enough Rope to Shoot Yourself in the Foot: Rules for C and C++ Programming
  75. The C++ Programming Language
  76. Effective C++: 55 Specific Ways to Improve Your Programs and Designs
  77. More Effective C++: 35 New Ways to Improve Your Programs and Designs
  78. More Effective C#: 50 Specific Ways to Improve Your C#
  79. CLR via C#
  80. Mr. Bunny's Big Cup o' Java
  81. Thinking in Java
  82. JUnit in Action
  83. Functional Programming in Scala
  84. The Art of Prolog: Advanced Programming Techniques
  85. The Craft of Prolog
  86. Programming Perl: Unmatched Power for Text Processing and Scripting
  87. Dive into Python 3
  88. why's (poignant) guide to Ruby
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/YuleTideCamel · 3 pointsr/learnprogramming

I complete agree with negative_epsilon. There is absolutely nothing wrong with C# and the .NET framework. People here on reddit like to hate on .NET but it is honestly a powerful framework. Visual Studio is the best IDE period, even people that hate .NET often admin that Visual Studio is an amazing development experience. For my personally, C# is my go to language for any new projects.

To give a little perspective, lots of companies worldwide choose .NET and many new startups (at least in my area) are on .NET and Microsoft Stack. Even StackOverlow is an example of really successful site built using C# and .NET.

Now about education I agree with the path already outlined, start with C# fundamentals, them web fundamentals, then asp.net mvc.

I thought offer some resources for learning:

PluralSight is a great training site. It's a paid site, but they do have a free trial and you might be able to get a free membership if you're a student.

Check out their library but I would recommend the following courses for you:

u/Midnight_Moopflops · 1 pointr/sysadmin

Another "lunches" book to read after the first is Powershell Toolmaking in a month of lunches there's another book coming out on the matter of Scripting later this year.

Also, for reference see if you can get Powershell in Action

It was written by the man who architected and designed the bloody thing, so you're in good hands. I've not read it cover to cover, but it's certainly the definitive reference on the subject.

All above books rated 5/5 stars on amazon by a lot of people.

If you're so bogged down, stitched up and scared to even think about automating anything, then I'd absolutely recommend The Phoenix Project this is the paradigm shift IT has gone through over the past decade. Essentially, IT has taken on board efficiency and best practices that have been standard in the manufacturing industry for decades, to incredible success.

Seriously, "Bag of Nails" IT shops are on their way out. If they're that unwilling to take a step back and do things the smart way, they're a shit company to work for. Learn about technical debt and why it's critical to pay it off.

DevOps and Site Reliability are in essence the latest buzzwords in IT service management, but there's a lot of positive change going on in the industry off the back of it. There's a sort of productivity Gold Rush.

If you're bogged down your current job sounds like the perfect place to cut your teeth and leapfrog off the back of it to move into a better organisation who wants to work smart.

Have fun!

u/NLeCompte_functional · 5 pointsr/fsharp

\> Would it transpile ALL of my code into JS? Wouldn’t that degrade performance?

​

If you implemented your numerical computations in the Fable app, yes, most likely. Although JavaScript can be used to write performant desktop applications - for instance, Visual Studio Code - I don't think it would be a good fit for scientific computing. The use case for Fable is in having behaviorally-sophisticated UIs without having to run through the dynamically/weakly-typed mess that is JavaScript. That said, JavaScript is not a terribly slow language - the Node.js JavaScript runtime is typically faster than Python. And Fable has Electron bindings for creating desktop apps. It could be worth trying. But I imagine a transpiled F# program would be noticeably slower than having one run in the .NET Framework or .NET Core runtime.

​

You really want to think of this as a UI layer on top of a computation layer. For a web application, the UI is typically run client-side in JavaScript (the browser sends .JS code to its JavaScript runtime, or in the very simplest case is only an HTML renderer), while the server code is some other language (F#, C++, PHP, etc) that sends user-facing data to the JavaScript. For a .NET desktop application, it'll all be bundled and run in the same place, but typically with a separate frontend project and a backend project. Unfortunately, either way it'll be a bit of work. And I think we'd need a bit more information about your code to give a good answer - for starters, is this Windows, or Linux? .NET Framework or .NET Core?

  • Honestly, using Windows.Forms or Eto Forms is the easiest way to solve the problem of "add a GUI to my F#." Compile your numerical code to a class library and create a separate project for the UI which references that library, then call the numeric functions you need from the UI.
    • /u/Mischala suggested the standard way F# devs add user interfaces to their desktop applications: in Visual Studio, C# desktop UIs can be built visually using the Forms designer, which is a tool that F# unfortunately lacks. The designer automates what would be extremely ugly and tedious code and lets you drag things around on a screen to build out your UI. Since C# and F# interoperate fairly nicely, you can reference your F# project from C# and call your functions directly. I imagine this would be the fastest way to add pictures and buttons.
    • If you don't want to get your hands dirty with C# - who would blame you :) - then it's really not that hard to write a forms application purely in F#. I am assuming, given your userbase, that aesthetics are a low priority, so you wouldn't need to learn anything fancy or play too much with resizing.etc. Here are some tutorials to get you started:
  • Like /u/Mischala said, turning your existing F# code into a webserver isn't a bad option.
    • Note that it doesn't actually have to be a real webserver hosted externally; an ASP.NET Core app is just a console application, and you can use the (amazing) Fable.Remoting library to have a webpage-based UI talk to the CLI console application.
    • Unfortunately you'll have a lot of useless boilerplate and overhead. Still, I think this would be the easiest way to use Fable for a high-performance desktop application. The Giraffe framework is both relatively easy to use and a lot of fun, and Visual Studio has an ASP.NET Core F# template out-of-the-box.
  • You could try forking Fable.Remoting and modify it to have it chat to a desktop application directly. This might be easy, but I don't know enough about JS to endorse it.
u/ThereKanBOnly1 · 7 pointsr/dotnet

I think you partially need to decide what area you want to focus on. Generally if you're going to delve into more advanced materials they should also be geared towards the in depth aspects of a specific technology, methodology, or problem.

I'll add a +1 for the design patterns suggestion. The Head First book is an option, but here is the book that I've got that is quite good. There's always the gang of 4 book, and although it is the "design patterns bible" its also a bit dry.

I'm also going to suggest Mark Seemann's Dependency Injection book. Although it is about DI and inversion of control containers, he also really focuses on SOLID design that makes DI more effective.

If you don't know what SOLID design principles are, then I'd brush up on that.

Turning specifically to C#, there's Jon Skeet's C# in Depth and also Jeremy Richter's CLR via C#. Both are great books are focused on roughly the same thing, understanding some of the inner workings of of the C# language, but they each approach it in a slightly different way. Although the CLR book came out before, C# in Depth seems to be a bit more highly regarded. I'd take a look at the TOC of each and see which one interests you more.

Outside of that, I'd say make sure that you really understand concepts like generics, reflection, and maybe even dive into understanding some MSIL.

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/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/letseatlunch · 1 pointr/csharp

I read "Professional ASP.NET MVC 3" about 3 years ago but it seems liek there is a MVC 5 version out now.

To your question about why is asp.net webforms becoming outdata. While there are many reasons I think the biggest is that MVC as a design pattern works really well web appplication development. Webforms is a great technology but it tries to enforce a stateful design pattern on web development which can make development harder. Stateful design patterns are better for desktop applications where as stateless applications are better for web applications. Lastly with MVC works better with a lot of the javascript frameworks out there that webforms really struggled to ingrate well with but a lot has been improved to fix this.

u/markdoubleyou · 3 pointsr/csharp

As others have mentioned, writing code is the best way to get exposure. But if you're a book guy like me then there are a lot of option out there that'll accelerate the process. You'd be insane to read all the following--these are just starting points that can accommodate different interests/tastes.

Having said that, I'll start with the one book that I think every C# developer should own:

Framework Design Guidelines: Conventions, Idioms, and Patterns for Reusable .NET Libraries

... it's a good read, and it includes a lot of direct input from the designers of the C# and the .NET Framework. Microsoft has been really good about sticking to those guidelines, so you'll immediately get a leg up on the Framework libraries if you work through this book. (Also, you'll win a lot of arguments with your coworkers about how APIs should be designed.)

General knowledge books (tons to pick from, but here are some winners):

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/basher117 · 1 pointr/csharp

There are couple books that really stood out for C#. These don't touch on .NET core but the same techniques apply.

Functional Programming in C#. http://amzn.to/2Ct3q5B if you come from a functional lang, this one is a must. Great LINQ concepts as well.


Adaptive Code via C@ http://amzn.to/2CsglEP is an updated version of the original. Dependencies and layering really helped me understand the core concepts of .NET. It's a M$ Press book. Easy read and a great reference.

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/JanJansen2634 · 1 pointr/dotnet

Isn't that book a bit deep for a newbie?

On topic: I'd go for something like Visual C# 2010 step-by-step, it's an easy read and covers everything you need to know.

WPF 4 Unleashed is also a must have, amazing book. Once you get to the WPF section of step-by-step transition to this one. The step-by-step book admits its WPF section is minimal and encourages you to look elsewhere.

Once you finish those then I'd pick up a more in depth one like Professional C# 4.0 and .NET 4 if you like.

EDIT: Just to add, I didn't use the eBook editions of WPF Unleashed or Professional C# 4.0 (hardcopy) so can't vouch for the quality of those, I have read all 3 though and own Step-By-Step as an ebook.

u/ZeroBugBounce · 1 pointr/learnprogramming

|will I ever have to use ArrayList again?

You are correct, no you wouldn't have to at least in the vast majority of cases. As an aside, If you use a generic List<T> with object as the type (List<object>) it will work the same way as ArrayList - but normally you'll rarely have to use object as the generic type parameter.

|How can I make it work, then?

The scenario I provided is kind of unlikely, and you won't be able to completely escape type restrictions. But there are ways to make that example code work, however I doubt you'd every have to or want to use them. If you must know, I was thinking of the implicit conversion operator - User could convert itself to and from int (if that made sense to do!). Also, C# as of .NET has the 'dynamic' keyword, which could help accomplish similar semantics.

I was just thinking, if you want the soup-to-nuts of the .NET type system, delegates, generics, LINQ, lambdas and everything else, you might want to look into some of the books that cover things both in breadth and depth. I would personally recommend Jon Skeet's C# in Depth and Jeffery Richter's CLR Via C# both of which are flat out amazing, IMHO.

u/evetsleep · 13 pointsr/PowerShell

If you're fairly new, I think you should start something like Learn Windows PowerShell in a Month of Lunches. You'll find this recommendation everywhere and for good reason. I personally was an peer reviewer of the 3rd edition and read it page-for-page slowly and provided a lot of feedback. It's a good book to get started with.

After that then move into the advanced tool making books like Learn PowerShell Toolmaking in a Month of Lunches.

Of course this just help get you started. You'll need to get a lot of practice with realistic projects to become familiar with how to build tools. I would highly recommend becoming very familiar with Git. There are a TON of tutorials out there (both web pages and YouTube videos).

Honestly to become a good toolmaker you'll need a lot of practice, but in terms of material these are a good source to get you started. Be patient and try to find small projects that you can grab onto. I would also recommend Windows PowerShell in Action for a more under-the-hood kind of view of how things work.

u/CaRDiaK · 1 pointr/learnprogramming

I'd learn ASPNET MVC. This gives you a clear progression and also touches on CSS, HTML & JavaScript. If you're going to be a professional programmer, you're going to need this whole party. Why not look into that and make like a movie site? Or a project site where you can put topics you want to learn and rate them, add comments etc.

Be careful with learning for learnings sake.. I did that for too long and it's only when you're actually solving problems that things really start to stick..

Oh and this is THE book on C#.. I've read so many and this is by far the best; https://www.amazon.co.uk/Adaptive-Code-via-Interface-Principles/dp/0735683204

Good luck! Send me a message if you get stuck or need any more help.

u/icewatersteam · 13 pointsr/programming

As you've already guessed C# really rules the roost for windows programming. If your starting out to learn C# and the framework then this book is really excellent.

http://www.amazon.com/2008-NET-Platform-Fourth-Windows-Net/dp/1590598849

It's for people who can already code and skips all the 'this is a variable, this is a array' stuff and goes to a nice depth of understanding what is actually going on in the framework.

Another great book is C# in depth by Jon Skeet, http://www.amazon.com/Depth-What-you-need-master/dp/1933988363/ref=sr_1_1?ie=UTF8&s=books&qid=1267539804&sr=1-1

this is another excellent book that will get you up to speed in the latest in c# language feature in no time.

Powershell is nice because it's a scripting lanuage but it can also use .net objects so you now have all the power of the .net framework at your disposal.

Check out mono as well, they move very quickly to keep up with the MS implementation.

p.s. here is my little controversial advice, depending on what the job marketplace is like in your area, you might want to consider doing some of the MS certs. People like to crap on them but I consider it like any form of learning, You get what you put into it. If jobs in your area are all behind the recruiterwall then having the MS dev certs does make it easy to get past them unfortunately.

u/The_Binding_Of_Data · 5 pointsr/csharp

It's going to depend on what you're putting in the list, but creating a new list each time is only going to create one additional object for the garbage collector to collect; the list object itself.

If the list is full of objects, each of those will need to be collected when they are no longer referenced by the list. This would happen in both the case where you clear the list (which will cause all the objects to be collected on the next run) or where you create a new new list (the objects will be collected when the list is collected).

The only way I see having the list be static making a big difference is if the list is hanging around long enough to be picked up in a gen 1 or gen 2 collection, but the records are only ever needed long enough to be picked up in a gen 0 collection.

In that case, reassigning the list would cause a gen 1 or 2 collection, which is more expensive than a gen 0 collection and could be avoided by clearing the list so the records are picked up in the gen 0.

If you're interested in optimizing .NET that much, I recommend Writing High-Performance .NET Code Second Ed.

u/jimschubert · 3 pointsr/csharp

I recommend starting by teaching some version control basics. Focus on git and quickly cover others like TFS and subversion. You can read Pro Git for free.

If you teach a hardware/software course, CODE is an excellent book.

I also recommend C# in Depth. I would also think it'd be cool to offer points for contributing to StackOverflow or the new open source .NET projects on GitHub.

If you teach design/analysis or other classes focused on architecture, Adaptive Code via C# is pretty good. I'm only a few chapters in, but it discusses Scrum methodology, layering and tiers, as well as how to follow practices for writing great code.

I would also suggest a course on JavaScript. I have had to train too many Junior and Senior developers on how to write JavaScript. It's scary that many web developers don't even understand fundamentals.

u/eMperror_ · 3 pointsr/learnprogramming

What did it for me was to start with architecture lectures by Uncle Bob (Robert C Martin). You can google "Clean Architecture Uncle Bob" and start there. If you are developing on mobile platforms, I suggest reading on the VIPER architecture. Getting yourself accustomed with known architectural patterns helps a lot. There is no magic to it, it's a bunch of standard patterns all hooked up together, and they each help you solve a specific problem in a clean fashion. With good architecture, there is usually no ambiguity on "where should I put my code for this feature?"

This is also a pretty good book explaining the SOLID principles, it's mainly targeting C# but it's concepts that you can reuse in languages like Java. This book is really good IMO.

u/Elite6809 · 1 pointr/teenagers

Started out in VB6 making silly little things about 7 or 8 years ago, never achieved much as I was on an old Windows 98 box with no internet access and I was too young to understand any complex programming I think the best thing I did was a Notepad clone that let you do a Caesar cipher on the document. Moved on to C# after someone I know got me this book. Stayed with it for a while, got a few more books on the subject from the same person and started to have a look at a few others, namely Java and Python.

Recently I've moved on to C which is much easier to work with on linux thanks to GCC. I've done a few things on github, namely this, which is a miner for someone's bitcoin clone written in C89. Fun stuff, learning about pointers. I had a look at some 6502 assembly language too, which is like the barebones instructions for the 6502 processor which the Commodore 64 (and the Atari 2600 I think) used. A bit too low-level for me so I got bored.

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/codechinchilla · 1 pointr/csharp

There isn't a 4th ed./C# 6 version out yet for this, but C# in Depth (http://www.amazon.com/Depth-3rd-Edition-Jon-Skeet/dp/161729134X) is basically all advanced C#/.NET topics, and extremely well written.

If you're looking to up your C# knowledge, definitely would recommend this book. (Also a lot of the C# 6 features are syntactic sugar, so you're not missing too much you can't get from an online source such as https://msdn.microsoft.com/en-us/magazine/dn879355.aspx)

u/pro-user · 1 pointr/webdev

Hhm. Well, first of all, I think you might have a hard time finding a book that will teach about both design and web development. Each of those are complicated enough to write separate books on. I think you'll be better off by finding two separate books (one on web dev, one on design) than finding one that combines both.

A kind of the same goes for Web. Dev. This is such a broad term, that you will hardly find any book that tries to cram in every possible aspect of web development. If you are a bit more specific and focus on a specific technology (like NodeJS, ASP.net with Angular or just plain old PHP, MySQL and JavaScript ) you'll get more value for money. There are more generic books out there, but the technologies (especially for web dev) change almost daily and books simply can't keep up with that. If you'd ask me, I think you'll be much better off having a good understanding of JavaScript in general before you move on to a specific stack or framework.

u/gospelwut · 1 pointr/learnprogramming

There's a good course by Google on Udacity at the moment - https://www.udacity.com/course/ud853 - which guides you through developing an app using their souped up version of Eclipse (Android Studio).

The nice thing about Android is you can run an emulator without XCode -- i.e. a Mac.

Depending on where your skills are at the moment, programming gis programming and the fundamentals are always important. You have to cut your teeth on something, but don't get caught in whatever framework/stack/paradigm you're working in. C# (Xamerin) is a great language, and it's what I started off with.

I'd say start off with something you want -- like the widget app. See if there's source code for some of the current Android reddit apps so you can get an idea of what's going on.

I cannot emphasize enough, however that you should eventually return to the meaty books/reading -- e.g. C# in Depth for C#. It's GOOD to try something and get frustrated; you'll see the value of good design and understanding in a way that being "told" cannot do.

u/FF56 · 1 pointr/Unity3D

Don't know about migration but this book is pretty great: http://www.amazon.com/5-0-Pocket-Reference-Instant-Programmers/dp/1449320171
Other than that just Google away!

u/fuckyournormality · 2 pointsr/csharp

I can highly recommend C#in Depth. It does not start with programming basics, instead it walks you through the evolution of the language version by version, which means not only that the more advanced topics are further down the road, but also gives you a very broad understanding about why the language has developed the way it has.

Edit: also +1 for Unity. It really gives you the freedom to focus on the important parts of game development.

u/[deleted] · 1 pointr/csharp

You would do well to invest in a copy a copy of CLR via C# by Jeffrey Richter. It's a great book that will answer this question, and a tonne of others in great detail.

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/lithermit · 2 pointsr/Unity2D

I recommend you get familiar with C# first, before even touching anything in Unity. Trying to tackle both programming and the engine at the same time is a lot of information; it's easy to get overwhelmed with just one of those things, let alone both.


I learned with this book


If you're adamant about video tutorials Brackeys seemed pretty good

u/Yorshelf · 1 pointr/learnprogramming

Look at this.
I put together this guide for web dev newcomers.
If you don't want to go through the whole guide, this video is really good at delivering an overview of a web application's different parts.

On another hand, if you pick a big good book (400+ pages)about a web framework (Rails for Ruby, Django for Python, ASP MVC for .NET,...), the authors will mention Angular, Auth, DB connections, Rest Api, as side or main topics.
Exemple of such books.

u/wartimespark · 2 pointsr/learnprogramming

Would you recommend C# In Depth?

Someone said it's a masterpiece. Another person said it's for someone who already knows a bit of C#.

I am ready to do what you said.

u/Innogator · 2 pointsr/csharp

I feel like the book Adaptive Code via C# was a great resource for me to advance to the next level as a developer. It covers all the topics you mentioned and helped me understand how to write more maintainable, well architected code.

Adaptive Code via C#

u/Ch3t · 2 pointsr/cscareerquestions

There are loads of C# jobs in enterprise software. Most are webdev. Signup for the 30 free trial of Pluralsight/Code School and do the ASP.NET/MVC courses. You can knock that out in a weekend and know enough to ace most interviews. Follow that up with SQL and ADO.NET. If you have time throw in some Entity Framework. MS has free video tutorials for all their technologies. If you don't like online learning, buy a book and work through it during lunch. I usually recommend Beginning ASP.NET 4.5 in C# and VB by Imar Spaanjaars. I read the 3.5 version. There were no typos in the code and the author actively answered questions on the Wrox bulletin board.

u/myevillaugh · 1 pointr/learnprogramming

Programming C# 4.0 is great for learning and starting out.

Once you're comfortable with the language, go through CLR via C#. This will teach you how things work in detail.

u/drmcclassy · 1 pointr/EngineeringStudents

For anyone getting into programming, I strongly recommend The Pragmatic Programmer

This is a little more specific, but if anyone is working with .Net, I'm currently reading CLR Via C# and I think it's amazing.

u/delphi_edict · 2 pointsr/csharp

There are two good texts that I'd recommend, each have their own bright spots. Pro MVC 5 and Professional Asp.net MVC 5.

u/PM_ME_YOUR_MAKEFILE · 3 pointsr/learnprogramming

I've also been learning C# for work, and I don't do well in classes: I learn better from books. So if books are your thing, here's a couple recommendations (all of these are on Safari Books Online, see if your work will shell out for a subscription)

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/steelesong · 1 pointr/web_design



HTML/CSS

This is a good resouce. If you want to work for a company, Id suggest learning asp. net. You can still primarily work with html/css but makes it easier for other back end developers to implement working forms, log in, etc

ASP .Net

u/TadgerOT · 1 pointr/xboxone

You should read this book..

https://www.amazon.co.uk/Adaptive-Code-via-patterns-principles/dp/0735683204

Especially the section on SCRUM and MVR.... really, really good book.

Edit : It will help give you an understanding of how software is developed at MS.

u/sleepybychoice · 1 pointr/learnprogramming

I've heard C# In Depth is pretty good. The author, Jon Skeet, works at Google and is apparently Chuck Norris as well.

Disclaimer: I never read the book.

u/BloodyThorn · 1 pointr/learnprogramming

This one for basic C# and OOP.

Beginning Visual C# 2010

O'Reilly has great reference books.

C# 4.0 in a Nutshell: The Definitive Reference

From there you can learn Mono for Android (and iOS)

Professional Android Programming with Mono for Android and .NET/C#

While learning XNA game development by example,

XNA 4.0 Game Development by Example: Beginner's Guide

And by detail...

Learning XNA 4.0: Game Development for the PC, Xbox 360, and Windows Phone 7

u/dsquid · 1 pointr/cscareerquestions

Grab a copy of Skeet's C# In Depth and consume it.

I suspect you'll find the transition pretty easy. Linq and lambdas may be a bit mind stretching at first, depending on your other experience.

As someone who spent 10+ years in Java and am doing C# currently for the last 3, I must say I strongly really prefer C#. OTOH, we use as little of the MS stack as possible otherwise: we rely on MySQL, Redis, and Servicestack

u/ChainSmokingPanda · 1 pointr/learnprogramming

Programming C# 4.0 is really excellent in my opinion. I came to it with a teenager's programming experience and still found it easy to follow. The book is huge, totaling at over 800 pages. It is mostly focused on C# itself, but in later chapters branches off into a lot of the subsets of .NET such as ASP.NET, WPF, WF, Silverlight, etc.

u/ShipOfHopes · 14 pointsr/csharp

I don't know how open you are to using more than one text, but Jon Skeet's C# in Depth is about as canon as it gets. A second-term course where C# basics are already understood would be great for this text. I can't speak for a truly introductory book, however.

u/rfinger1337 · 4 pointsr/csharp

That's an interesting point. I can't remember seeing books that target experienced devs that use exercises. They tend to say "here's how this works."

http://www.amazon.com/Depth-3rd-Edition-Jon-Skeet/dp/161729134X

^ I don't think there are exercises, but I like Jon's writing style and his technical knowledge is beyond reproach.

u/saddertadder · 2 pointsr/csharp

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

is the book I recommend. I learned how to do ASP MVC from it years ago.

One thing is what do you wanna do - ASP MVC 5 which is pretty established or ASP MVC 6, which has lots of features I'd say overwhelm a new beginner

u/seabre · 7 pointsr/cscareerquestions

Java and C# are very very similar.

> How do you more experienced developers go about teaching yourself a new language?

Google and books. This book is pretty decent.

u/videoj · 0 pointsr/learnprogramming

Since you're studying Mathematics, you might be better off looking at functional programming,rather then OOP. F# from Microsoft offers both functional and OOP. A good introduction is F# for Scientists . As for performance, there are a number of benchmarks showing F# matching or beating equivalent C++ programs.

u/king_crais · 4 pointsr/dotnet

Two books that I thought were good:

Pro ASP.NET MVC

Professional ASP.NET

u/noobzilla · 13 pointsr/csharp

CLR via C# for a better understanding of the runtime you're working with.

C# in Depth for a deep dive into the language and it's features and their details of implementation.

I'd consider those two to be the primary intermediate texts.

u/contrarian · 1 pointr/learnprogramming

So far I am kind of happy with this get the kindle version and read it on your laptop and run the examples in VS Express. $16 and it will take you at a whole bunch of hours to go through the content, more if you want to really learn it in dept and use each learning nugget to search for more information about it online.

u/realzequel · 2 pointsr/dotnet

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

u/frozentedwilliams · 1 pointr/learnprogramming

This book has been invaluable for me. It skips all the basic stuff and focuses on the feature set of .net and c#. Things like delegate and extension methods, LINQ, nullable types, and generics. It clocks in at only around 350 pages, too, so you can probably absorb it in a long weekend. And if you're interviewing specifically for a c# position, you should probably be able to write some code that isn't almost completely interchangeable with java.

u/adamoo403 · 3 pointsr/PowerShell

PowerShell in Action is apparently quite good. I read somewhere if you wanted a more in depth read on what/how powershell is doing, more so than in 'A month of lunches' then this is the one you want. I haven't read it myself, but I have the 3rd edition on order and its due in May

u/Poloniculmov · 2 pointsr/Romania

wiki zice ca Zamiatin ar fi o influenta pt Ursula Le Guin, trebuie sa incerc.

Din cartile de IT e ceva bun? Eu am recitit de curand CLR via C# si o ultra recomand oricui scrie C#.

u/americio · 1 pointr/csharp

For a quick overlook, this. And for a little bit more detail, this one.

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.

u/zachary12 · -1 pointsr/learnprogramming

Not much help re: which language. Logic would dictate the next move to be language agnostic design patterns, re-factoring et alli. <- ignore, did not read.

For a decent C# book, I'd recommend CLR via C# (http://www.amazon.com/CLR-via-C-Jeffrey-Richter/dp/0735627045)/

u/epoxxy · 1 pointr/learnprogramming

Beginning visual c#
On a side note,in a few months you could have learned a lot, no matter the sources....