Customer Reviews

Regular Expressions with .NET

5 star:		(9)
4 star:		(3)
3 star:		(2)
2 star:		(1)
1 star:		(0)

 

 

Once you become serious about .NET, you'll find Regular Expressions staring you square in the face. They're there and they are very important, but the .NET documentation doesn't help much in learning about Regular Expressions and how to work with them in .NET.
That's where Dan Appleman's Ebook comes in. I think that Dan has done an absolutley stupendous job in the following 3 areas:
a) Dan explains the essence of Regular Expressions from a general perspective. After all, "Regular Expressions" is a language unto itself, even without .NET. This Ebook gives you a good intuitive feel of how pattern matching is expressed with the "Regular Expressions" language.
b) The Ebook shines in its explanation of .NET's take on Regular Expressions. This book thoroughly explores the various classes and methods that .NET offers for working with Regular Expressions. Dan does a great job teaching you about Groups and Captures.
c) The code download for the book is top-notch. Clearly, there was a lot of thought put into providing meaningful examples to help the reader internalize the .NET approach to processing with
Regular Expression.
I think the Ebook format is perfect for this topic.
I have one criticism, though. I believe that the advertising glop at the end of the end of the Ebook is somewhat extraneous.
A link to this material should have been sufficient.

I'm a bit disappointed in this book. I find regular expressions to be a challenging subject, and I was looking for a clear tutorial that would start with the basics and work its way up to more complex expressions. On that basis, I bought this book.

The book's explanation of the basics are a bit thin for my tastes. For example, it jumps into groups and backreferencing on page 11, while I'm still struggling with more basic concepts. If you already 'get' regular expressions, this book is probably a good text. However, if you are struggling with the fundamentals, as I am, you may view its explanation as being weak.

My previous knowledge of Regular Expressions was minimal - I knew that they existed and they they were supposedly "powerful", but other than that, I was in the dark.

With a background in .Net, it was easy for me to pick up the skill with the help of Appleman and his relatively short eBook on the subject. Now I can't wait to apply my new skill to some projects that I have in the hopper.

The thing I like most about Appleman is that he always seems to be learning the subject along with you instead of sitting up on a perch of all-knowingness and spilling down information to you. I look forward to reading more from the founder of aPress.

To add to the previous reviews:

- he does a good job of building from the ground up - starts with a very clear english explanation before you start in on the examples.

- separates advanced topics from basic issues, making it easy to learn first what you need, and then what you want

- provides a nice summary in the back, like a regular expression help desk reference

- the download code is pretty shoddy, contrary to the other review's comments, but it does get the job done and it's from playing around with the compiled executables that you'll really gain understanding.

if you're finding yourself searching around newsgroups looking for a 'numeric regular expression validator' or something and then copying and pasting code that you don't understand, get this book. It's not hard, but you probably won't pick it up on your own.

.02

If all I had wanted was an introduction to Regular Expressions in .NET, this book would have been fine, I guess. However, I had already learned quite a bit from Microsoft's documentation, and was hoping for a clear elucidation of a few points that MS had glossed over, to wit, how to use balancing expressions and alternating constructs, and also how to do some tricky things such as finding everything that doesn't match a given pattern, etc. Appleman indeed addresses the balancing expressions and alternating constructs in greater depth than the MS documentation, but his treatise is somewhat inadequate. He gives one elaborate example which uses both constructions, but fails to explain how to generalize from his example; and the regex pattern in his example itself, which is supposed to return the contents of successively nested parentheses, is not a general solution at all, but only works on a fairly narrow set of test cases. I think this stems from him having a less-than-profound understanding of regular expressions himself: he all but admits that he simply banged his head against the wall of Microsoft's documentation until he figured stuff out. Can't blame him for trying; this stuff is some of the most abstruse and dreadful stuff I've ever seen, in thirty years of professional programming. I just wish I could find something a bit more comprehensive (and comprehensible) from somebody who REALLY knows what the underlying interpreter/compiler does. All the better stuff that I've seen out there is unaware of the particulars of the .Net environment. Bottom line: since you can't get a refund on the e-book, save your money and re-read the Microsoft Stuff a few more times.

I've read through it once, and I'll definitely have to read through it again. And probably at least once more after that. It's the perfect size for a download - small enough that I could handle printing it out, and I still have the .pdf file for when I need to search it. It's pretty dense, and there's a lot of "You need to understand 3 things about xxWhatever, and I'll explain the 3rd thing later on", but let's face it, RegEx is a VERY complicated, meaty topic. He's got an appendix to handle getting all the escape codes etc in one place for reference. The best thing is that he includes a link to free software, a RegEx tester that you can download so you can test his examples to see how they work, and then, of course, test your own expressions. If you are really new to Regular Expressions, Jeffrey E.F. Friedl has written a 430 page book, Mastering Regular Expressions, which you might also want to consider.

I've followed Dan for a long time, and this isn't the first book of his I love. However, there isn't much in the VS.Net documentation that is even remotely intelligible.

Dan comes up with great examples and explains everything very clearly. I had already had some exposure to them from reading Balena's book, so I could hit the ground running. However, even if you don't have the first clue of what a Regex is, this book can help you.

Good books are cheap at any price, and considering how good and how cheap this book is, download it!

Very good primer, but needed more examples with "real-world" relevance to better demonstrate some of the more complex features of regular expressions.

The good:
--Provides a quick look at the regular expression components of .net.
--Verbose enough to give you some idea of how to use the components.
--Much better than the Microsoft documentation.
--Provides examples in both C# and vb.net (this is a Microsoft centric book, obviousy....)

The bad:
--Not enough examples. I humbly suggest some exercises/answers to test yourself. It wouldn't add much to the virtual page count but could help solidify concepts.
--Downloadable code works but doesn't seem at all polished.
--Some examples could be better documented (E.G. better identify which is Group 1, Group 2, etc.)

The ugly:
--Grammar errors. In an e-book there is really no excuse for these errors. C'mon, lets get them fixed in revision 2.
--Errors in examples. If you understand the concept, you'll figure out what is wrong. If you're struggling with a concept, you don't need the additional errors.

Initially I read the MS docs trying to understand Regex. This is definately NOT the way to start. I highly recommend this ebook first. After an hour with it I already a far greater understanding of using Regex and more importantly (for me) the Regex object hierarchy and how it fits together.