PRZEDMIOTEM OFERTY JEST KOD DOSTĘPOWY DO KSIĄŻKI ELEKTRONICZNEJ (EBOOK)

KSIĄŻKA JEST DOSTĘPNA NA ZEWNĘTRZNEJ PLATFORMIE. KSIĄŻKA NIE JEST W POSTACI PLIKU.

When you have questions about C# ASK_FOR_LINK_2 or the .NET CLR and its core Framework assemblies, this bestselling guide has the answers you need. C# has become a language of unusual flexibility and breadth since its premiere in 2000, but this continual growth means there’s still much more to learn. Organized around concepts and use cases, this thoroughly updated sixth edition provides intermediate and advanced programmers with a concise map of C# and .NET knowledge. Dive in and discover why this Nutshell guide is considered the definitive reference on C#. Get up to speed with all aspects of the C# language, from the basics of syntax and variables, to advanced topics such as pointers and operator overloading Dig deep into LINQ via three chapters dedicated to the topic Learn about dynamic, asynchronous, and parallel programming Work with .NET features, including XML, networking, serialization, reflection, security, application domains, and code contracts Explore the new C# ASK_FOR_LINK_2 compiler-as-a-service, Roslyn

• Autorzy: Joseph Albahari
• Wydawnictwo: O'Reilly Media, Inc.
• Data wydania: 2015
• Wydanie: 6
• Liczba stron:
• Forma publikacji: PDF (online)
• Język publikacji: angielski
• ISBN: 9781491927106

BRAK MOŻLIWOŚCI POBRANIA PLIKU. Drukowanie: OGRANICZENIE DO 10 stron. Kopiowanie: OGRANICZENIE DO 10 stron.

• Copyright
• Table of Contents
• Preface
• Intended Audience
• How This Book Is Organized
• What You Need to Use This Book
• Conventions Used in This Book
• Using Code Examples
• Safari Books Online
• How to Contact Us
• Acknowledgments
• Joseph Albahari
• Ben Albahari
• Chapter 1. Introducing C# and the .NET Framework
• Object Orientation
• Type Safety
• Memory Management
• Platform Support
• C#’s Relationship with the CLR
• The CLR and .NET Framework
• C# and Windows Runtime
• What’s New in C# ASK_FOR_LINK_2
• What Was New in C# ASK_FOR_LINK_2
• What Was New in C# ASK_FOR_LINK_2
• What Was New in C# ASK_FOR_LINK_2
• Chapter 2. C# Language Basics
• A First C# Program
• Compilation
• Syntax
• Identifiers and Keywords
• Literals, Punctuators, and Operators
• Comments
• Type Basics
• Predefined Type Examples
• Custom Type Examples
• Conversions
• Value Types Versus Reference Types
• Predefined Type Taxonomy
• Numeric Types
• Numeric Literals
• Numeric Conversions
• Arithmetic Operators
• Increment and Decrement Operators
• Specialized Integral Operations
• 8- and 16-Bit Integrals
• Special Float and Double Values
• double Versus decimal
• Real-Number Rounding Errors
• Boolean Type and Operators
• Bool Conversions
• Equality and Comparison Operators
• Conditional Operators
• Strings and Characters
• Char Conversions
• String Type
• Arrays
• Default Element Initialization
• Multidimensional Arrays
• Simplified Array Initialization Expressions
• Bounds Checking
• Variables and Parameters
• The Stack and the Heap
• Definite Assignment
• Default Values
• Parameters
• varImplicitly Typed Local Variables
• Expressions and Operators
• Primary Expressions
• Void Expressions
• Assignment Expressions
• Operator Precedence and Associativity
• Operator Table
• Null Operators
• Null-Coalescing Operator
• Null-conditional operator (C# 6)
• Statements
• Declaration Statements
• Expression Statements
• Selection Statements
• Iteration Statements
• Jump Statements
• Miscellaneous Statements
• Namespaces
• The using Directive
• using static (C# 6)
• Rules Within a Namespace
• Aliasing Types and Namespaces
• Advanced Namespace Features
• Chapter 3. Creating Types in C#
• Classes
• Fields
• Methods
• Instance Constructors
• Object Initializers
• The this Reference
• Properties
• Indexers
• Constants
• Static Constructors
• Static Classes
• Finalizers
• Partial Types and Methods
• The nameof operator (C# 6)
• Inheritance
• Polymorphism
• Casting and Reference Conversions
• Virtual Function Members
• Abstract Classes and Abstract Members
• Hiding Inherited Members
• Sealing Functions and Classes
• The base Keyword
• Constructors and Inheritance
• Overloading and Resolution
• The object Type
• Boxing and Unboxing
• Static and Runtime Type Checking
• The GetType Method and typeof Operator
• The ToString Method
• Object Member Listing
• Structs
• Struct Construction Semantics
• Access Modifiers
• Examples
• Friend Assemblies
• Accessibility Capping
• Restrictions on Access Modifiers
• Interfaces
• Extending an Interface
• Explicit Interface Implementation
• Implementing Interface Members Virtually
• Reimplementing an Interface in a Subclass
• Interfaces and Boxing
• Enums
• Enum Conversions
• Flags Enums
• Enum Operators
• Type-Safety Issues
• Nested Types
• Generics
• Generic Types
• Why Generics Exist
• Generic Methods
• Declaring Type Parameters
• typeof and Unbound Generic Types
• The default Generic Value
• Generic Constraints
• Subclassing Generic Types
• Self-Referencing Generic Declarations
• Static Data
• Type Parameters and Conversions
• Covariance
• Contravariance
• C# Generics Versus C++ Templates
• Chapter 4. Advanced C#
• Delegates
• Writing Plug-in Methods with Delegates
• Multicast Delegates
• Instance Versus Static Method Targets
• Generic Delegate Types
• The Func and Action Delegates
• Delegates Versus Interfaces
• Delegate Compatibility
• Events
• Standard Event Pattern
• Event Accessors
• Event Modifiers
• Lambda Expressions
• Explicitly Specifying Lambda Parameter Types
• Capturing Outer Variables
• Anonymous Methods
• try Statements and Exceptions
• The catch Clause
• The finally Block
• Throwing Exceptions
• Key Properties of ASK_FOR_LINK_2
• Common Exception Types
• The TryXXX Method Pattern
• Alternatives to Exceptions
• Enumeration and Iterators
• Enumeration
• Collection Initializers
• Iterators
• Iterator Semantics
• Composing Sequences
• Nullable Types
• Nullable<T> struct
• Implicit and explicit nullable conversions
• Boxing and unboxing nullable values
• Operator Lifting
• bool? with & and | Operators
• Nullable Types & Null Operators
• Scenarios for Nullable Types
• Alternatives to Nullable Types
• Operator Overloading
• Operator Functions
• Overloading Equality and Comparison Operators
• Custom Implicit and Explicit Conversions
• Overloading true and false
• Extension Methods
• Extension Method Chaining
• Ambiguity and Resolution
• Anonymous Types
• Dynamic Binding
• Static Binding Versus Dynamic Binding
• Custom Binding
• Language Binding
• RuntimeBinderException
• Runtime Representation of Dynamic
• Dynamic Conversions
• var Versus dynamic
• Dynamic Expressions
• Dynamic Calls Without Dynamic Receivers
• Static Types in Dynamic Expressions
• Uncallable Functions
• Attributes
• Attribute Classes
• Named and Positional Attribute Parameters
• Attribute Targets
• Specifying Multiple Attributes
• Caller Info Attributes (C# 5)
• Unsafe Code and Pointers
• Pointer Basics
• Unsafe Code
• The fixed Statement
• The Pointer-to-Member Operator
• Arrays
• void*
• Pointers to Unmanaged Code
• Preprocessor Directives
• Conditional Attributes
• Pragma Warning
• XML Documentation
• Standard XML Documentation Tags
• User-Defined Tags
• Type or Member Cross-References
• Chapter 5. Framework Overview
• The CLR and Core Framework
• System Types
• Text Processing
• Collections
• Queries
• XML
• Diagnostics and Code Contracts
• Concurrency and Asynchrony
• Streams and I/O
• Networking
• Serialization
• Assemblies, Reflection, and Attributes
• Dynamic Programming
• Security
• Advanced Threading
• Parallel Programming
• Application Domains
• Native and COM Interoperability
• Applied Technologies
• User Interface Technologies
• Backend Technologies
• Distributed System Technologies
• Chapter 6. Framework Fundamentals
• String and Text Handling
• Char
• String
• Comparing Strings
• StringBuilder
• Text Encodings and Unicode
• Dates and Times
• TimeSpan
• DateTime and DateTimeOffset
• Dates and Time Zones
• DateTime and Time Zones
• DateTimeOffset and Time Zones
• TimeZone and TimeZoneInfo
• Daylight Saving Time and DateTime
• Formatting and Parsing
• ToString and Parse
• Format Providers
• Standard Format Strings and Parsing Flags
• Numeric Format Strings
• NumberStyles
• Date/Time Format Strings
• DateTimeStyles
• Enum Format Strings
• Other Conversion Mechanisms
• Convert
• XmlConvert
• Type Converters
• BitConverter
• Globalization
• Globalization Checklist
• Testing
• Working with Numbers
• Conversions
• Math
• BigInteger
• Complex
• Random
• Enums
• Enum Conversions
• Enumerating Enum Values
• How Enums Work
• Tuples
• Comparing Tuples
• The Guid Struct
• Equality Comparison
• Value Versus Referential Equality
• Standard Equality Protocols
• Equality and Custom Types
• Order Comparison
• IComparable
• < and >
• Implementing the IComparable Interfaces
• Utility Classes
• Console
• Environment
• Process
• AppContext
• Chapter 7. Collections
• Enumeration
• IEnumerable and IEnumerator
• IEnumerable<T> and IEnumerator<T>
• Implementing the Enumeration Interfaces
• The ICollection and IList Interfaces
• ICollection<T> and ICollection
• IList<T> and IList
• IReadOnlyList<T>
• The Array Class
• Construction and Indexing
• Enumeration
• Length and Rank
• Searching
• Sorting
• Reversing Elements
• Copying
• Converting and Resizing
• Lists, Queues, Stacks, and Sets
• List<T> and ArrayList
• LinkedList<T>
• Queue<T> and Queue
• Stack<T> and Stack
• BitArray
• HashSet<T> and SortedSet<T>
• Dictionaries
• IDictionary<TKey,TValue>
• IDictionary
• Dictionary<TKey,TValue> and Hashtable
• OrderedDictionary
• ListDictionary and HybridDictionary
• Sorted Dictionaries
• Customizable Collections and Proxies
• Collection<T> and CollectionBase
• KeyedCollection<TKey,TItem> and DictionaryBase
• ReadOnlyCollection<T>
• Plugging in Equality and Order
• IEqualityComparer and EqualityComparer
• IComparer and Comparer
• StringComparer
• IStructuralEquatable and IStructuralComparable
• Chapter 8. LINQ Queries
• Getting Started
• Fluent Syntax
• Chaining Query Operators
• Composing Lambda Expressions
• Natural Ordering
• Other Operators
• Query Expressions
• Range Variables
• Query Syntax Versus SQL Syntax
• Query Syntax Versus Fluent Syntax
• Mixed-Syntax Queries
• Deferred Execution
• Reevaluation
• Captured Variables
• How Deferred Execution Works
• Chaining Decorators
• How Queries Are Executed
• Subqueries
• Subqueries and Deferred Execution
• Composition Strategies
• Progressive Query Building
• The into Keyword
• Wrapping Queries
• Projection Strategies
• Object Initializers
• Anonymous Types
• The let Keyword
• Interpreted Queries
• How Interpreted Queries Work
• Combining Interpreted and Local Queries
• AsEnumerable
• LINQ to SQL and Entity Framework
• LINQ to SQL Entity Classes
• Entity Framework Entity Classes
• DataContext and ObjectContext
• Associations
• Deferred Execution with L2S and EF
• DataLoadOptions
• Eager Loading in Entity Framework
• Updates
• API Differences Between L2S and EF
• Building Query Expressions
• Delegates Versus Expression Trees
• Expression Trees
• Chapter 9. LINQ Operators
• Overview
• SequenceSequence
• SequenceElement or Value
• VoidSequence
• Filtering
• Where
• Take and Skip
• TakeWhile and SkipWhile
• Distinct
• Projecting
• Select
• SelectMany
• Joining
• Join and GroupJoin
• The Zip Operator
• Ordering
• OrderBy, OrderByDescending, ThenBy, and ThenByDescending
• Grouping
• GroupBy
• Set Operators
• Concat and Union
• Intersect and Except
• Conversion Methods
• OfType and Cast
• ToArray, ToList, ToDictionary, and ToLookup
• AsEnumerable and AsQueryable
• Element Operators
• First, Last, and Single
• ElementAt
• DefaultIfEmpty
• Aggregation Methods
• Count and LongCount
• Min and Max
• Sum and Average
• Aggregate
• Quantifiers
• Contains and Any
• All and SequenceEqual
• Generation Methods
• Empty
• Range and Repeat
• Chapter 10. LINQ to XML
• Architectural Overview
• What Is a DOM?
• The LINQ to XML DOM
• X-DOM Overview
• Loading and Parsing
• Saving and Serializing
• Instantiating an X-DOM
• Functional Construction
• Specifying Content
• Automatic Deep Cloning
• Navigating and Querying
• Child Node Navigation
• Parent Navigation
• Peer Node Navigation
• Attribute Navigation
• Updating an X-DOM
• Simple Value Updates
• Updating Child Nodes and Attributes
• Updating Through the Parent
• Working with Values
• Setting Values
• Getting Values
• Values and Mixed Content Nodes
• Automatic XText Concatenation
• Documents and Declarations
• XDocument
• XML Declarations
• Names and Namespaces
• Namespaces in XML
• Specifying Namespaces in the X-DOM
• The X-DOM and Default Namespaces
• Prefixes
• Annotations
• Projecting into an X-DOM
• Eliminating Empty Elements
• Streaming a Projection
• Transforming an X-DOM
• Chapter 11. Other XML Technologies
• XmlReader
• Reading Nodes
• Reading Elements
• Reading Attributes
• Namespaces and Prefixes
• XmlWriter
• Writing Attributes
• Writing Other Node Types
• Namespaces and Prefixes
• Patterns for Using XmlReader/XmlWriter
• Working with Hierarchical Data
• Mixing XmlReader/XmlWriter with an X-DOM
• XSD and Schema Validation
• Performing Schema Validation
• XSLT
• Chapter 12. Disposal and Garbage Collection
• IDisposable, Dispose, and Close
• Standard Disposal Semantics
• When to Dispose
• Opt-in Disposal
• Clearing Fields in Disposal
• Automatic Garbage Collection
• Roots
• Garbage Collection and WinRT
• Finalizers
• Calling Dispose from a Finalizer
• Resurrection
• How the Garbage Collector Works
• Optimization Techniques
• Forcing Garbage Collection
• Tuning Garbage Collection
• Memory Pressure
• Managed Memory Leaks
• Timers
• Diagnosing Memory Leaks
• Weak References
• Weak References and Caching
• Weak References and Events
• Chapter 13. Diagnostics and Code Contracts
• Conditional Compilation
• Conditional Compilation Versus Static Variable Flags
• The Conditional Attribute
• Debug and Trace Classes
• Fail and Assert
• TraceListener
• Flushing and Closing Listeners
• Code Contracts Overview
• Why Use Code Contracts?
• Contract Principles
• Preconditions
• ASK_FOR_LINK_2
• ASK_FOR_LINK_2<TException>
• ASK_FOR_LINK_2
• Preconditions and Overridden Methods
• Postconditions
• ASK_FOR_LINK_2
• ASK_FOR_LINK_2<TException>
• ASK_FOR_LINK_2<T> and ASK_FOR_LINK_2<T>
• ASK_FOR_LINK_2<T>
• Postconditions and Overridden Methods
• Assertions and Object Invariants
• Assertions
• Object Invariants
• Contracts on Interfaces and Abstract Methods
• Dealing with Contract Failure
• The ContractFailed Event
• Exceptions Within Contract Conditions
• Selectively Enforcing Contracts
• Contracts in Release Builds
• Call-Site Checking
• Static Contract Checking
• The ContractVerification Attribute
• Baselines
• The SuppressMessage Attribute
• Debugger Integration
• Attaching and Breaking
• Debugger Attributes
• Processes and Process Threads
• Examining Running Processes
• Examining Threads in a Process
• StackTrace and StackFrame
• Windows Event Logs
• Writing to the Event Log
• Reading the Event Log
• Monitoring the Event Log
• Performance Counters
• Enumerating the Available Counters
• Reading Performance Counter Data
• Creating Counters and Writing Performance Data
• The Stopwatch Class
• Chapter 14. Concurrency and Asynchrony
• Introduction
• Threading
• Creating a Thread
• Join and Sleep
• Blocking
• Local Versus Shared State
• Locking and Thread Safety
• Passing Data to a Thread
• Exception Handling
• Foreground Versus Background Threads
• Thread Priority
• Signaling
• Threading in Rich-Client Applications
• Synchronization Contexts
• The Thread Pool
• Tasks
• Starting a Task
• Returning values
• Exceptions
• Continuations
• TaskCompletionSource
• ASK_FOR_LINK_2
• Principles of Asynchrony
• Synchronous Versus Asynchronous Operations
• What is Asynchronous Programming?
• Asynchronous Programming and Continuations
• Why Language Support Is Important
• Asynchronous Functions in C#
• Awaiting
• Writing Asynchronous Functions
• Asynchronous Lambda Expressions
• Asynchronous Methods in WinRT
• Asynchrony and Synchronization Contexts
• Optimizations
• Asynchronous Patterns
• Cancellation
• Progress Reporting
• The Task-based Asynchronous Pattern (TAP)
• Task Combinators
• Obsolete Patterns
• Asynchronous Programming Model (APM)
• Event-Based Asynchronous Pattern (EAP)
• BackgroundWorker
• Chapter 15. Streams and I/O
• Stream Architecture
• Using Streams
• Reading and Writing
• Seeking
• Closing and Flushing
• Timeouts
• Thread Safety
• Backing Store Streams
• FileStream
• MemoryStream
• PipeStream
• BufferedStream
• Stream Adapters
• Text Adapters
• Binary Adapters
• Closing and Disposing Stream Adapters
• Compression Streams
• Compressing in Memory
• Working with ZIP Files
• File and Directory Operations
• The File Class
• The Directory Class
• FileInfo and DirectoryInfo
• Path
• Special Folders
• Querying Volume Information
• Catching Filesystem Events
• File I/O in Windows Runtime
• Working with Directories
• Working with Files
• Isolated Storage in Windows Store Apps
• Memory-Mapped Files
• Memory-Mapped Files and Random File I/O
• Memory-Mapped Files and Shared Memory
• Working with View Accessors
• Isolated Storage
• Isolation Types
• Reading and Writing Isolated Storage
• Store Location
• Enumerating Isolated Storage
• Chapter 16. Networking
• Network Architecture
• Addresses and Ports
• URIs
• Client-Side Classes
• WebClient
• WebRequest and WebResponse
• HttpClient
• Proxies
• Authentication
• Exception Handling
• Working with HTTP
• Headers
• Query Strings
• Uploading Form Data
• Cookies
• Forms Authentication
• SSL
• Writing an HTTP Server
• Using FTP
• Using DNS
• Sending Mail with SmtpClient
• Using TCP
• Concurrency with TCP
• Receiving POP3 Mail with TCP
• TCP in Windows Runtime
• Chapter 17. Serialization
• Serialization Concepts
• Serialization Engines
• Formatters
• Explicit Versus Implicit Serialization
• The Data Contract Serializer
• DataContractSerializer Versus NetDataContractSerializer
• Using the Serializers
• Serializing Subclasses
• Object References
• Version Tolerance
• Member Ordering
• Null and Empty Values
• Data Contracts and Collections
• Subclassed Collection Elements
• Customizing Collection and Element Names
• Extending Data Contracts
• Serialization and Deserialization Hooks
• Interoperating with [Serializable]
• Interoperating with IXmlSerializable
• The Binary Serializer
• Getting Started
• Binary Serialization Attributes
• [NonSerialized]
• [OnDeserializing] and [OnDeserialized]
• [OnSerializing] and [OnSerialized]
• [OptionalField] and Versioning
• Binary Serialization with ISerializable
• Subclassing Serializable Classes
• XML Serialization
• Getting Started with Attribute-Based Serialization
• Subclasses and Child Objects
• Serializing Collections
• IXmlSerializable
• Chapter 18. Assemblies
• What’s in an Assembly
• The Assembly Manifest
• The Application Manifest
• Modules
• The Assembly Class
• Strong Names and Assembly Signing
• How to Strongly Name an Assembly
• Delay Signing
• Assembly Names
• Fully Qualified Names
• The AssemblyName Class
• Assembly Informational and File Versions
• Authenticode Signing
• How to Sign with Authenticode
• Authenticode Validation
• The Global Assembly Cache
• How to Install Assemblies to the GAC
• GAC and Versioning
• Resources and Satellite Assemblies
• Directly Embedding Resources
• .resources Files
• .resx Files
• Satellite Assemblies
• Cultures and Subcultures
• Resolving and Loading Assemblies
• Assembly and Type Resolution Rules
• AssemblyResolve
• Loading Assemblies
• Deploying Assemblies Outside the Base Folder
• Packing a Single-File Executable
• Selective Patching
• Working with Unreferenced Assemblies
• Chapter 19. Reflection and Metadata
• Reflecting and Activating Types
• Obtaining a Type
• Type Names
• Base Types and Interfaces
• Instantiating Types
• Generic Types
• Reflecting and Invoking Members
• Member Types
• C# Members Versus CLR Members
• Generic Type Members
• Dynamically Invoking a Member
• Method Parameters
• Using Delegates for Performance
• Accessing Nonpublic Members
• Generic Methods
• Anonymously Calling Members of a Generic Interface
• Reflecting Assemblies
• Loading an Assembly into a Reflection-Only Context
• Modules
• Working with Attributes
• Attribute Basics
• The AttributeUsage Attribute
• Defining Your Own Attribute
• Retrieving Attributes at Runtime
• Retrieving Attributes in the Reflection-Only Context
• Dynamic Code Generation
• Generating IL with DynamicMethod
• The Evaluation Stack
• Passing Arguments to a Dynamic Method
• Generating Local Variables
• Branching
• Instantiating Objects and Calling Instance Methods
• Exception Handling
• Emitting Assemblies and Types
• Saving Emitted Assemblies
• The ASK_FOR_LINK_2 Object Model
• Emitting Type Members
• Emitting Methods
• Emitting Fields and Properties
• Emitting Constructors
• Attaching Attributes
• Emitting Generic Methods and Types
• Defining Generic Methods
• Defining Generic Types
• Awkward Emission Targets
• Uncreated Closed Generics
• Circular Dependencies
• Parsing IL
• Writing a Disassembler
• Chapter 20. Dynamic Programming
• The Dynamic Language Runtime
• Numeric Type Unification
• Dynamic Member Overload Resolution
• Simplifying the Visitor Pattern
• Anonymously Calling Members of a Generic Type
• Implementing Dynamic Objects
• DynamicObject
• ExpandoObject
• Interoperating with Dynamic Languages
• Passing State Between C# and a Script
• Chapter 21. Security
• Permissions
• CodeAccessPermission and PrincipalPermission
• PermissionSet
• Declarative Versus Imperative Security
• Code Access Security (CAS)
• How Code Access Security Is Applied
• Testing for Full Trust
• Allowing Partially Trusted Callers
• Elevation of Privilege
• APTCA and [SecurityTransparent]
• The Transparency Model
• How the Transparency Model Works
• How to Write APTCA Libraries with Transparency
• Transparency in Full-Trust Scenarios
• Sandboxing Another Assembly
• Asserting Permissions
• Operating System Security
• Running in a Standard User Account
• Administrative Elevation and Virtualization
• Identity and Role Security
• Assigning Users and Roles
• Cryptography Overview
• Windows Data Protection
• Hashing
• Symmetric Encryption
• Encrypting in Memory
• Chaining Encryption Streams
• Disposing Encryption Objects
• Key Management
• Public Key Encryption and Signing
• The RSA Class
• Digital Signing
• Chapter 22. Advanced Threading
• Synchronization Overview
• Exclusive Locking
• The lock Statement
• ASK_FOR_LINK_2 and ASK_FOR_LINK_2
• Choosing the Synchronization Object
• When to Lock
• Locking and Atomicity
• Nested Locking
• Deadlocks
• Performance
• Mutex
• Locking and Thread Safety
• Thread Safety and .NET Framework Types
• Thread Safety in Application Servers
• Immutable Objects
• Nonexclusive Locking
• Semaphore
• Reader/Writer Locks
• Signaling with Event Wait Handles
• AutoResetEvent
• ManualResetEvent
• CountdownEvent
• Creating a Cross-Process EventWaitHandle
• Wait Handles and Continuations

W tej ofercie kupujesz kod dostępowy umożliwiający dostęp do wskazanej treści. Kod umożliwia dostęp do treści za pomocą przeglądarki WWW, dedykowanej aplikacji iOS (Apple) ze sklepu App Store lub dedykowanej aplikacji Android ze sklepu Play. Kod oraz instrukcje otrzymasz pocztą elektroniczną niezwłocznie po zaksięgowaniu płatności. Brak możliwości pobrania pliku.

Na podstawie art. 38 pkt 13 Ustawy z dnia 30 maja 2014 roku o prawach konsumenta realizując kod dostępowy rezygnujesz z prawa do odstąpienia od umowy zawartej na odległość.

Typ licencji: licencja wieczysta.

BRAK MOŻLIWOŚCI POBRANIA PLIKU.

NIE PRZESYŁAMY PLIKÓW E-MAILEM.