• Fri frakt över 249 kr
  • •
  • Snabba leveranser
  • •
  • Billiga böcker
Kundservice

Du är på sajten för privatpersoner.

Företag, bibliotek eller offentlig verksamhet?

Du handlar på classic.bokus.com, där alla dina funktioner finns intakta.
Till classic.bokus.com
Bokus logotyp. Gå till startsidan.
  • Erbjudanden
  • Student
  • Topplistor
  • Barn & ungdom
  • Bokus Play
  • E-böcker
  • Ljudböcker
  • Pocketböcker
  • Spel och pussel

Pocketfynda! Hundratals böcker för 49 kr/st →

Sidfot

Mina sidor

    Hjälp

    • Kundservice
    • Vanliga frågor och svar
    • Frakt och leverans
    • Retur vid ångerrätt
    • Reklamera vara
    • Betalning
    • Köpvillkor
    • Allmänna villkor
    • Information om webbplatsens tillgänglighet

    Om Bokus

    • Om oss
    • Pressrum
    • För studenter
    • För företag
    • För bibliotek och offentlig verksamhet
    • För leverantörer
    • Hållbarhet

    Populärt

    • Aktuella erbjudanden
    • Presentkort
    • Studentlitteratur
    • Nya böcker
    • Topplistor
    • Signerade böcker
    • Engelska böcker

    Inspiration

    • Boktips
    • BookTok
    • Barnbokskaraktärer
    • Populära författare
    Logotyp för Bokus
    Följ oss på Facebook (extern länk)Följ oss på Instagram (extern länk)Följ oss på YouTube (extern länk)Följ oss på TikTok (extern länk)
    bokus @ CookiesAnpassa cookiesIntegritetspolicyKöpvillkor
    Till Citymail hemsida (extern länk)Till Budbee hemsida (extern länk)Till Postnord hemsida (extern länk)Till Schenker hemsida (extern länk)Till Early Bird hemsida (extern länk)Till Walleys hemsida (extern länk)
    1. Data och IT
    2. Programmeringsböcker

    More Effective C#

    50 Specific Ways to Improve Your C#

    AvBill Wagner

    Häftad, Engelska, 2017

    Del i serien Effective Software Development Series

    304 kr

    Beställningsvara. Skickas inom 7-10 vardagar. Fri frakt över 249 kr.

    Fler format och utgåvor

    E-bok

    594 kr

    E-bok

    413 kr

    Beskrivning

    In More Effective C#, Second Edition, world-renowned .NET expert Bill Wagner identifies and illuminates 50 intermediate-to-advanced techniques for writing exceptionally robust and well-performing C# 7.0 code. Reflecting the growing sophistication of the C# language and its development community, Wagner presents powerful new solutions to problems you’re likely to encounter every day.

    Through three editions of Effective C#, Wagner’s clear explanations, expert tips, and realistic code examples have proven invaluable to hundreds of thousands of developers. With the publication of this title, Effective C#, Third Edition, and More Effective C#, Second Edition, have been completely reorganized to provide clear explanations, expert tips, and realistic code examples in a cohesive package for modern C#. More Effective C#, Second Edition, brings the same proven approach to the new features in C# 7.0, helping you perform familiar tasks more efficiently and effectively.

    Drawing on his unsurpassed C# experience and key role on global C# standards committees, Wagner addresses object-oriented, functional, and service-oriented approaches to managing data with C#; better ways to express your intent to users and other programmers; and new opportunities to leverage powerful asynchronous and dynamic programming techniques.

    • Use properties instead of accessible data members (Item 1)
    • Distinguish between value and reference types (Item 4)
    • Understand relationships among multiple concepts of equality (Item 9)
    • Avoid conversion operators in your APIs (Item 11)
    • Understand how interface and virtual methods differ (Item 15)
    • Avoid overloading methods defined in base classes (Item 19)
    • Create method groups that are clear, minimal, and complete (Item 22)
    • Enable immediate error reporting in iterators and async methods (Item 26)
    • Use async methods for async work (Item 27)
    • Avoid thread allocations and context switches (Item 30)
    • Construct PLINQ parallel algorithms with exceptions in mind (Item 36)
    • Use the thread pool instead of creating threads (Item 37)
    • Use BackgroundWorker for cross-thread communication (Item 38)
    • Use the smallest possible scope for lock handles (Item 41)
    • Understand the pros and cons of dynamic programming (Item 43)
    • Make full use of the expression API (Item 46)
    • Minimize dynamic objects in public APIs (Item 47)

    You’re already a successful C# programmer: this book will make you an outstanding one.

    Content Update Program: This title is no longer part of the Content Update Program. The content is final, and no further updates will be released.

    Produktinformation

    • Utgivningsdatum:2017-09-05
    • Mått:176 x 231 x 14 mm
    • Vikt:460 g
    • Format:Häftad
    • Språk:Engelska
    • Serie:Effective Software Development Series
    • Antal sidor:304
    • Upplaga:2
    • Förlag:Pearson Education
    • ISBN:9780672337888

    Utforska kategorier

    • Programmeringsböcker inom Data och IT
    • Programspråk inom Data och IT

    Mer om författaren

    Bill Wagner is one of the world’s foremost C# developers, a member of the ECMA C# Standards Committee, and author of all three editions of Effective C#. He is president of the Humanitarian Toolbox, has been awarded Microsoft Regional Director and .NET MVP for 11 years, and was recently appointed to the .NET Foundation Advisory Council. Wagner has helped companies ranging from start-ups to enterprises to improve development processes and grow development teams. Now a member of Microsoft’s .NET Core content team, he creates developer learning materials on the C# language and .NET Core.

    Innehållsförteckning

    • Introduction xiChapter 1: Working with Data Types 1Item 1: Use Properties Instead of Accessible Data Members 1Item 2: Prefer Implicit Properties for Mutable Data 8Item 3: Prefer Immutability for Value Types 12Item 4: Distinguish Between Value Types and Reference Types 18Item 5: Ensure That 0 Is a Valid State for Value Types 24Item 6: Ensure That Properties Behave Like Data 28Item 7: Limit Type Scope by Using Tuples 34Item 8: Define Local Functions on Anonymous Types 39Item 9: Understand the Relationships Among the Many Different Concepts of Equality 45Item 10: Understand the Pitfalls of GetHashCode() 54Chapter 2: API Design 61Item 11: Avoid Conversion Operators in Your APIs 61Item 12: Use Optional Parameters to Minimize Method Overloads 65Item 13: Limit Visibility of Your Types 69Item 14: Prefer Defining and Implementing Interfaces to Inheritance 73Item 15: Understand How Interface Methods Differ from Virtual Methods 82Item 16: Implement the Event Pattern for Notifications 86Item 17: Avoid Returning References to Internal Class Objects 93Item 18: Prefer Overrides to Event Handlers 97Item 19: Avoid Overloading Methods Defined in Base Classes 100Item 20: Understand How Events Increase Runtime Coupling Among Objects 104Item 21: Declare Only Nonvirtual Events 107Item 22: Create Method Groups That Are Clear, Minimal, and Complete 113Item 23: Give Partial Classes Partial Methods for Constructors, Mutators, and Event Handlers 120Item 24: Avoid ICloneable Because It Limits Your Design Choices 125Item 25: Limit Array Parameters to params Arrays 129Item 26: Enable Immediate Error Reporting in Iterators and Async Methods Using Local Functions 134Chapter 3: Task-Based Asynchronous Programming 139Item 27: Use Async Methods for Async Work 139Item 28: Never Write async void Methods 143Item 29: Avoid Composing Synchronous and Asynchronous Methods 149Item 30: Use Async Methods to Avoid Thread Allocations and Context Switches 154Item 31: Avoid Marshalling Context Unnecessarily 156Item 32: Compose Asynchronous Work Using Task Objects 160Item 33: Consider Implementing the Task Cancellation Protocol 166Item 34: Cache Generalized Async Return Types 173Chapter 4: Parallel Processing 177Item 35: Learn How PLINQ Implements Parallel Algorithms 177Item 36: Construct Parallel Algorithms with Exceptions in Mind 189Item 37: Use the Thread Pool Instead of Creating Threads 195Item 38: Use BackgroundWorker for Cross-Thread Communication 201Item 39: Understand Cross-Thread Calls in XAML Environments 205Item 40: Use lock() as Your First Choice for Synchronization 214Item 41: Use the Smallest Possible Scope for Lock Handles 221Item 42: Avoid Calling Unknown Code in Locked Sections 225Chapter 5: Dynamic Programming 229Item 43: Understand the Pros and Cons of Dynamic Typing 229Item 44: Use Dynamic Typing to Leverage the Runtime Type of Generic Type Parameters 238Item 45: Use DynamicObject or IDynamicMetaObjectProvider for Data-Driven Dynamic Types 242Item 46: Understand How to Use the Expression API 253Item 47: Minimize Dynamic Objects in Public APIs 259Chapter 6: Participate in the Global C# Community 267Item 48: Seek the Best Answer, Not the Most Popular Answer 267Item 49: Participate in Specs and Code 269Item 50: Consider Automating Practices with Analyzers 271Index 273