What Types Of Options Are There – FAQ

Best Binary Options Brokers: 2020 Ranking
  • Binarium

    Best Choice! The leader in our ranking!
    Perfect for beginners!
    Free Demo Acc + Free Trading Education!

  • Binomo

    Good choice for experienced traders!

Are there different types of personal health records (PHRs)?

The Basics

Yes, there are two main kinds of personal health records (PHRs).

  • Standalone Personal Health Records: With a standalone PHR, patients fill in information from their own records, and the information is stored on patients’ computers or the Internet. In some cases, a standalone PHR can also accept data from external sources, including providers and laboratories. With a standalone PHR, patients could add diet or exercise information to track progress over time. Patients can decide whether to share the information with providers, family members, or anyone else involved in their care.
  • Tethered/Connected Personal Health Records: A tethered, or connected, PHR is linked to a specific health care organization’s electronic health record (EHR) system or to a health plan’s information system. With a tethered PHR, patients can access their own records through a secure portal and see, for example, the trend of their lab results over the last year, their immunization history, or due dates for screenings.

For More Information

For more information on PHRs and the different types of PHRs, see the following resources.

What Types Of Options Are There? – FAQ

Common “Bugs” That Aren’t Bugs

I’ve found a long-overlooked bug in TypeScript!

Here are some behaviors that may look like bugs, but aren’t.

  • These two empty classes can be used in place of each other
    • See the FAQ Entry on this page
  • I can use a non- void -returning function where one returning void is expected
    • See the FAQ Entry on this page
    • Prior discussion at #4544
  • I’m allowed to use a shorter parameter list where a longer one is expected
    • See the FAQ Entry on this page
    • Prior discussion at #370, #9300, #9765, #9825, #13043, #16871, #13529, #13977, #17868, #20274, #20541, #21868, #26324, #30876
  • private class members are actually visible at runtime
    • See the FAQ Entry on this page for a commonly suggested “fix”
    • Prior discussion at #564, #1537, #2967, #3151, #6748, #8847, #9733, #11033
  • This conditional type returns never when it should return the true branch.
    • See this issue for discussion about distributive conditional types.
  • This mapped type returns a primitive type, not an object type.
    • Mapped types declared as < [ K in keyof T ]: U >where T is a type parameter are known as homomorphic mapped types, which means that the mapped type is a structure preserving function of T . When type parameter T is instantiated with a primitive type the mapped type evaluates to the same primitive.
  • A method and a function property of the same type behave differently.
    • Methods are always bivariant in their argument, while function properties are contravariant in their argument under strictFunctionTypes . More discussion here.

Common Feature Requests

I want to request one of the following features.

Here’s a list of common feature requests and their corresponding issue. Please leave comments in these rather than logging new issues.

  • Safe navigation operator, AKA CoffeeScript’s null conditional/propagating/propagation operator, AKA C#’s’ ?. operator #16
  • Minification #8
  • Extension methods #9
  • Partial classes #563
  • Something to do with this #513
  • Strong typing of Function members call / bind / apply #212
  • Runtime function overloading #3442

Type System Behavior

What is structural typing?

TypeScript uses structural typing. This system is different than the type system employed by some other popular languages you may have used (e.g. Java, C#, etc.)

The idea behind structural typing is that two types are compatible if their members are compatible. For example, in C# or Java, two classes named MyPoint and YourPoint , both with public int properties x and y , are not interchangeable, even though they are identical. But in a structural type system, the fact that these types have different names is immaterial. Because they have the same members with the same types, they are identical.

This applies to subtype relationships as well. In C++, for example, you could only use a Dog in place of an Animal if Animal was explicitly in Dog ‘s class heritage. In TypeScript, this is not the case – a Dog with at least as many members (with appropriate types) as Animal is a subtype of Animal regardless of explicit heritage.

This can have some surprising consequences for programmers accustomed to working in a nominally-typed language. Many questions in this FAQ trace their roots to structural typing and its implications. Once you grasp the basics of it, however, it’s very easy to reason about.

What is type erasure?

TypeScript removes type annotations, interfaces, type aliases, and other type system constructs during compilation.

This means that at run-time, there is no information present that says that some variable x was declared as being of type SomeInterface .

The lack of run-time type information can be surprising for programmers who are used to extensively using reflection or other metadata systems. Many questions in this FAQ boil down to “because types are erased”.

Why are getters without setters not considered read-only?

I wrote some code like this and expected an error:

This is now an error in TypeScript 2.0 and later. See #12 for the suggestion tracking this issue.

Why are function parameters bivariant?

I wrote some code like this and expected an error:

This is an unsoundness resulting from the lack of explicit covariant/contravariant annotations in the type system. Because of this omission, TypeScript must be more permissive when asked whether (x: Dog) => void is assignable to (x: Animal) => void .

To understand why, consider two questions: Is Dog[] a subtype of Animal[] ? Should Dog[] be a subtype of Animal[] in TypeScript?

The second question (should Dog[] be a subtype of Animal[] ?) is easier to analyze. What if the answer was “no”?

This would be incredibly annoying. The code here is 100% correct provided that checkIfAnimalsAreAwake doesn’t modify the array. There’s not a good reason to reject this program on the basis that Dog[] can’t be used in place of Animal[] – clearly a group of Dog s is a group of Animal s here.

Back to the first question. When the type system decides whether or not Dog[] is a subtype of Animal[] , it does the following computation (written here as if the compiler took no optimizations), among many others:

  • Is Dog[] assignable to Animal[] ?
  • Is each member of Dog[] assignable to Animal[] ?
    • Is Dog[].push assignable to Animal[].push ?
      • Is the type (x: Dog) => number assignable to (x: Animal) => number ?
        • Is the first parameter type in (x: Dog) => number assignable to or from first parameter type in (x: Animal) => number ?
          • Is Dog assignable to or from Animal ?
            • Yes.

As you can see here, the type system must ask “Is the type (x: Dog) => number assignable to (x: Animal) => number ?”, which is the same question the type system needed to ask for the original question. If TypeScript forced contravariance on parameters (requiring Animal being assignable to Dog ), then Dog[] would not be assignable to Animal[] .

In summary, in the TypeScript type system, the question of whether a more-specific-type-accepting function should be assignable to a function accepting a less-specific type provides a prerequisite answer to whether an array of that more specific type should be assignable to an array of a less specific type. Having the latter not be the case would not be an acceptable type system in the vast majority of cases, so we have to take a correctness trade-off for the specific case of function argument types.

Why are functions with fewer parameters assignable to functions that take more parameters?

I wrote some code like this and expected an error:

This is the expected and desired behavior. First, refer to the “substitutability” primer at the top of the FAQ — handler is a valid argument for callback because it can safely ignore extra parameters.

Second, let’s consider another case:

This is isomorphic to the example that “wanted” an error. At runtime, forEach invokes the given callback with three arguments (value, index, array), but most of the time the callback only uses one or two of the arguments. This is a very common JavaScript pattern and it would be burdensome to have to explicitly declare unused parameters.

But forEach should just mark its parameters as optional! e.g. forEach(callback: (element?: T, index?: number, array?: T[]))

This is not what an optional callback parameter means. Function signatures are always read from the caller’s perspective. If forEach declared that its callback parameters were optional, the meaning of that is ” forEach might call the callback with 0 arguments“.

The meaning of an optional callback parameter is this:

forEach always provides all three arguments to its callback. You don’t have to check for the index argument to be undefined – it’s always there; it’s not optional.

There is currently not a way in TypeScript to indicate that a callback parameter must be present. Note that this sort of enforcement wouldn’t ever directly fix a bug. In other words, in a hypothetical world where forEach callbacks were required to accept a minimum of one argument, you’d have this code:

which would be “fixed”, but not made any more correct, by adding a parameter:

Why are functions returning non- void assignable to function returning void ?

I wrote some code like this and expected an error:

This is the expected and desired behavior. First, refer to the “substitutability” primer — the fact that doSomething returns “more” information than callMeMaybe is a valid substitution.

Second, let’s consider another case:

This is isomorphic to the example that “wanted” an error. Array#push returns a number (the new length of the array), but it’s a safe substitute to use for a void -returning function.

Another way to think of this is that a void -returning callback type says “I’m not going to look at your return value, if one exists”.

Why are all types assignable to empty interfaces?

I wrote some code like this and expected an error:

Types with no members can be substituted by any type. In this example, window , 42 , and ‘huh?’ all have the required members of a Thing (there are none).

In general, you should never find yourself declaring an interface with no properties.

Can I make a type alias nominal?

I wrote the following code and expected an error:

Type aliases are simply aliases — they are indistinguishable from the types they refer to.

A workaround involving intersection types to make “branded primitives” is possible:

You’ll need to add a type assertion wherever a value of this type is created. These can still be aliased by string and lose type safety.

How do I prevent two types from being structurally compatible?

I would like the following code to produce an error:

A possible fix if you really want two types to be incompatible is to add a ‘brand’ member:

Note that this will require a type assertion wherever ‘branded’ objects are created:

See also #202 for a suggestion tracking making this more intuitive.

How do I check at run-time if an object implements some interface?

I want to write some code like this:

TypeScript types are erased (https://en.wikipedia.org/wiki/Type_erasure) during compilation. This means there is no built-in mechanism for performing runtime type checks. It’s up to you to decide how you want to distinguish objects. A popular method is to check for properties on an object. You can use user-defined type guards to accomplish this:

Why doesn’t this incorrect cast throw a runtime error?

TypeScript has type assertions, not type casts. The intent of x is to say “TypeScript, please treat x as a T “, not to perform a type-safe run-time conversion. Because types are erased, there is no direct equivalent of C#’s expr as type or (type)expr syntax.

Why don’t I get type checking for (number) => string or (T) => T ?

I wrote some code like this and expected an error:

Parameter names in function types are required. The code as written describes a function taking one parameter named number of type any . In other words, this declaration

is equivalent to this one

You should instead write:

To avoid this problem, turn on the noImplicitAny flag, which will issue a warning about the implicit any parameter type.

Why am I getting an error about a missing index signature?

These three functions seem to do the same thing, but the last one is an error. Why is this the case?

This isn’t now an error in TypeScript 1.8 and later. As for earlier versions:

Contextual typing occurs when the context of an expression gives a hint about what its type might be. For example, in this initialization:

The expression y gets a contextual type of number because it’s initializing a value of that type. In this case, nothing special happens, but in other cases more interesting things will occur.

One of the most useful cases is functions:

How did the compiler know that s was a string ? If you wrote that function expression by itself, s would be of type any and there wouldn’t be any error issued. But because the function was contextually typed by the type of x , the parameter s acquired the type string . Very useful!

At the same time, an index signature specifies the type when an object is indexed by a string or a number . Naturally, these signatures are part of type checking:

The lack of an index signature is also important:

The problem with assuming that objects don’t have index signatures is that you then have no way to initialize an object with an index signature:

The solution is that when an object literal is contextually typed by a type with an index signature, that index signature is added to the type of the object literal if it matches. For example:

Let’s look at the original function:

Because result ‘s type does not have an index signature, the compiler throws an error.

Why am I getting Supplied parameters do not match any signature error?

A function or a method implementation signature is not part of the overloads.

When having at least one overload signature declaration, only the overloads are visible. The last signature declaration, also known as the implementation signature, does not contribute to the shape of your signature. So to get the desired behavior you will need to add an additional overload:

The rationale here is that since JavaScript does not have function overloading, you will be doing parameter checking in your function, and this your function implementation might be more permissive than what you would want your users to call you through.

For instance you can require your users to call you using matching pairs of arguments, and implement this correctly without having to allow mixed argument types:

Why can’t I use x in the destructuring function f(< x: number >) < /* . */ >?

I wrote some code like this and got an unexpected error:

Destructuring syntax is counterintuitive for those accustomed to looking at TypeScript type literals. The syntax f() declares a destructuring from the property x to the local number .

Looking at the emitted code for this is instructive:

To write this code correctly, you should write:

If you can provide a default for all properties, it’s preferable to write:

Why do these empty classes behave strangely?

I wrote some code like this and expected an error:

See the question “Why are all types assignable to empty interfaces?” in this FAQ. It’s worth re-iterating the advice from that answer: in general, you should never declare a class with no properties. This is true even for subclasses:

Alpha and Bravo are structurally identical to each other, and to Base . This has a lot of surprising effects, so don’t do it! If you want Alpha and Bravo to be different, add a private property to each.

When and why are classes nominal?

What explains the difference between these two lines of code?

In TypeScript, classes are compared structurally. The one exception to this is private and protected members. When a member is private or protected, it must originate in the same declaration to be considered the same as another private or protected member.

Why does this get orphaned in my instance methods?

Synonyms and alternate symptoms:

  • Why are my class properties undefined in my callback?
  • Why does this point to window in my callback?
  • Why does this point to undefined in my callback?
  • Why am I getting an error this.someMethod is not a function ?
  • Why am I getting an error Cannot read property ‘someMethod’ of undefined ?

In JavaScript, the value of this inside a function is determined as follows:

  1. Was the function the result of calling .bind ? If so, this is the first argument passed to bind
  2. Was the function directly invoked via a property access expression expr.method() ? If so, this is expr
  3. Otherwise, this is undefined (in “strict” mode), or window in non-strict mode

The offending problem is this line of code:

Here, we provided a function reference to obj.someCallback to setTimeout . The function was then invoked on something that wasn’t the result of bind and wasn’t directly invoked as a method. Thus, this in the body of someCallback referred to window (or undefined in strict mode).

What’s the difference between Bar and typeof Bar when Bar is a class ?

I wrote some code like this and don’t understand the error I’m getting:

It’s important to remember that in JavaScript, classes are just functions. We refer to the class object itself — the value MyClass — as a constructor function. When a constructor function is invoked with new , we get back an object that is an instance of the class.

So when we define a class, we actually define two different types.

The first is the one referred to by the class’ name; in this case, MyClass . This is the instance type of the class. It defines the properties and methods that an instance of the class has. It’s the type returned by invoking the class’ constructor.

The second type is anonymous. It is the type that the constructor function has. It contains a construct signature (the ability to be invoked with new ) that returns an instance of the class. It also contains any static properties and methods the class might have. This type is typically referred to as the “static side” of the class because it contains those static members (as well as being the constructor for the class). We can refer to this type with the type query operator typeof .

The typeof operator (when used in a type position) expresses the type of an expression. Thus, typeof MyClass refers to the type of the expression MyClass – the constructor function that produces instances of MyClass .

Why do my derived class property initializers overwrite values set in the base class constructor?

See #1617 for this and other initialization order questions

What’s the difference between declare class and interface ?

TODO: Write up common symptoms of declare class / interface confusion.

What does it mean for an interface to extend a class?

This makes a type called Bar that has the same members as the instance shape of Foo . However, if Foo has private members, their corresponding properties in Bar must be implemented by a class which has Foo in its heritage. In general, this pattern is best avoided, especially if Foo has private members.

Why am I getting “TypeError: [base class name] is not defined in __extends ?

I’m seeing a runtime error in __extends :

The most common cause of this is that your HTML page includes a

You signed in with another tab or window. Reload to refresh your session. You signed out in another tab or window. Reload to refresh your session.

Storage account overview

An Azure storage account contains all of your Azure Storage data objects: blobs, files, queues, tables, and disks. The storage account provides a unique namespace for your Azure Storage data that is accessible from anywhere in the world over HTTP or HTTPS. Data in your Azure storage account is durable and highly available, secure, and massively scalable.

To learn how to create an Azure storage account, see Create a storage account.

Types of storage accounts

Azure Storage offers several types of storage accounts. Each type supports different features and has its own pricing model. Consider these differences before you create a storage account to determine the type of account that is best for your applications. The types of storage accounts are:

  • General-purpose v2 accounts: Basic storage account type for blobs, files, queues, and tables. Recommended for most scenarios using Azure Storage.
  • General-purpose v1 accounts: Legacy account type for blobs, files, queues, and tables. Use general-purpose v2 accounts instead when possible.
  • BlockBlobStorage accounts: Storage accounts with premium performance characteristics for block blobs and append blobs. Recommended for scenarios with high transactions rates, or scenarios that use smaller objects or require consistently low storage latency.
  • FileStorage accounts: Files-only storage accounts with premium performance characteristics. Recommended for enterprise or high performance scale applications.
  • BlobStorage accounts: Legacy Blob-only storage accounts. Use general-purpose v2 accounts instead when possible.

The following table describes the types of storage accounts and their capabilities:

Storage account type Supported services Supported performance tiers Supported access tiers Replication options Deployment model
General-purpose V2 Blob, File, Queue, Table, Disk, and Data Lake Gen2
Standard, Premium Hot, Cool, Archive LRS, GRS, RA-GRS, ZRS, GZRS (preview), RA-GZRS (preview) Resource Manager Encrypted
General-purpose V1 Blob, File, Queue, Table, and Disk Standard, Premium N/A LRS, GRS, RA-GRS Resource Manager, Classic Encrypted
BlockBlobStorage Blob (block blobs and append blobs only) Premium N/A LRS, ZRS Resource Manager Encrypted
FileStorage File only Premium N/A LRS, ZRS Resource Manager Encrypted
BlobStorage Blob (block blobs and append blobs only) Standard Hot, Cool, Archive LRS, GRS, RA-GRS Resource Manager Encrypted

General-purpose v2 accounts

General-purpose v2 storage accounts support the latest Azure Storage features and incorporate all of the functionality of general-purpose v1 and Blob storage accounts. General-purpose v2 accounts deliver the lowest per-gigabyte capacity prices for Azure Storage, as well as industry-competitive transaction prices. General-purpose v2 storage accounts support these Azure Storage services:

  • Blobs (all types: Block, Append, Page)
  • Data Lake Gen2
  • Files
  • Disks
  • Queues
  • Tables

Microsoft recommends using a general-purpose v2 storage account for most scenarios. You can easily upgrade a general-purpose v1 or Blob storage account to a general-purpose v2 account with no downtime and without the need to copy data.

For more information on upgrading to a general-purpose v2 account, see Upgrade to a general-purpose v2 storage account.

General-purpose v2 storage accounts offer multiple access tiers for storing data based on your usage patterns. For more information, see Access tiers for block blob data.

General-purpose v1 accounts

General-purpose v1 storage accounts provide access to all Azure Storage services, but may not have the latest features or the lowest per gigabyte pricing. General-purpose v1 storage accounts support these Azure Storage services:

You should use general-purpose v2 accounts in most cases. You can use general-purpose v1 accounts for these scenarios:

Best Binary Options Brokers: 2020 Ranking
  • Binarium

    Best Choice! The leader in our ranking!
    Perfect for beginners!
    Free Demo Acc + Free Trading Education!

  • Binomo

    Good choice for experienced traders!

Your applications require the Azure classic deployment model. General-purpose v2 accounts and Blob storage accounts support only the Azure Resource Manager deployment model.

Your applications are transaction-intensive or use significant geo-replication bandwidth, but don’t require large capacity. In this case, general-purpose v1 may be the most economical choice.

You use a version of the Storage Services REST API that is earlier than 2020-02-14 or a client library with a version lower than 4.x. You can’t upgrade your application.

BlockBlobStorage accounts

A BlockBlobStorage account is a specialized storage account in the premium performance tier for storing unstructured object data as block blobs or append blobs. Compared with general-purpose v2 and BlobStorage accounts, BlockBlobStorage accounts provide low, consistent latency and higher transaction rates.

BlockBlobStorage accounts don’t currently support tiering to hot, cool, or archive access tiers. This type of storage account does not support page blobs, tables, or queues.

FileStorage accounts

A FileStorage account is a specialized storage account used to store and create premium file shares. This storage account kind supports files but not block blobs, append blobs, page blobs, tables, or queues.

FileStorage accounts offer unique performance dedicated characteristics such as IOPS bursting. For more information on these characteristics, see the File share storage tiers section of the Files planning guide.

Naming storage accounts

When naming your storage account, keep these rules in mind:

  • Storage account names must be between 3 and 24 characters in length and may contain numbers and lowercase letters only.
  • Your storage account name must be unique within Azure. No two storage accounts can have the same name.

Performance tiers

Depending on the type of storage account you create, you can choose between standard and premium performance tiers.

General-purpose storage accounts

General-purpose storage accounts may be configured for either of the following performance tiers:

  • A standard performance tier for storing blobs, files, tables, queues, and Azure virtual machine disks. For more information about scalability targets for standard storage accounts, see Scalability targets for standard storage accounts.
  • A premium performance tier for storing unmanaged virtual machine disks. Microsoft recommends using managed disks with Azure virtual machines instead of unmanaged disks. For more information about scalability targets for the premium performance tier, see Scalability targets for premium page blob storage accounts.

BlockBlobStorage storage accounts

BlockBlobStorage storage accounts provide a premium performance tier for storing block blobs and append blobs. For more information, see Scalability targets for premium block blob storage accounts.

FileStorage storage accounts

FileStorage storage accounts provide a premium performance tier for Azure file shares. For more information, see Azure Files scalability and performance targets.

Access tiers for block blob data

Azure Storage provides different options for accessing block blob data based on usage patterns. Each access tier in Azure Storage is optimized for a particular pattern of data usage. By selecting the right access tier for your needs, you can store your block blob data in the most cost-effective manner.

The available access tiers are:

  • The Hot access tier. This tier is optimized for frequent access of objects in the storage account. Accessing data in the hot tier is most cost-effective, while storage costs are higher. New storage accounts are created in the hot tier by default.
  • The Cool access tier. This tier is optimized for storing large amounts of data that is infrequently accessed and stored for at least 30 days. Storing data in the cool tier is more cost-effective, but accessing that data may be more expensive than accessing data in the hot tier.
  • The Archive tier. This tier is available only for individual block blobs. The archive tier is optimized for data that can tolerate several hours of retrieval latency and that will remain in the archive tier for at least 180 days. The archive tier is the most cost-effective option for storing data. However, accessing that data is more expensive than accessing data in the hot or cool tiers.

If there’s a change in the usage pattern of your data, you can switch between these access tiers at any time. For more information about access tiers, see Azure Blob storage: hot, cool, and archive access tiers.

Changing the access tier for an existing storage account or blob may result in additional charges. For more information, see the Storage account billing section.


Redundancy options for a storage account include:

  • Locally redundant storage (LRS): A simple, low-cost redundancy strategy. Data is copied synchronously three times within the primary region.
  • Zone-redundant storage (ZRS): Redundancy for scenarios requiring high availability. Data is copied synchronously across three Azure availability zones in the primary region.
  • Geo-redundant storage (GRS): Cross-regional redundancy to protect against regional outages. Data is copied synchronously three times in the primary region, then copied asynchronously to the secondary region. For read access to data in the secondary region, enable read-access geo-redundant storage (RA-GRS).
  • Geo-zone-redundant storage (GZRS) (preview): Redundancy for scenarios requiring both high availability and maximum durability. Data is copied synchronously across three Azure availability zones in the primary region, then copied asynchronously to the secondary region. For read access to data in the secondary region, enable read-access geo-zone-redundant storage (RA-GZRS).

For more information about redundancy options in Azure Storage, see Azure Storage redundancy.


All data in your storage account is encrypted on the service side. For more information about encryption, see Azure Storage Service Encryption for data at rest.

Storage account endpoints

A storage account provides a unique namespace in Azure for your data. Every object that you store in Azure Storage has an address that includes your unique account name. The combination of the account name and the Azure Storage service endpoint forms the endpoints for your storage account.

For example, if your general-purpose storage account is named mystorageaccount, then the default endpoints for that account are:

  • Blob storage: https://*mystorageaccount*.blob.core.windows.net
  • Table storage: https://*mystorageaccount*.table.core.windows.net
  • Queue storage: https://*mystorageaccount*.queue.core.windows.net
  • Azure Files: https://*mystorageaccount*.file.core.windows.net

Block blob and blob storage accounts expose only the Blob service endpoint.

Construct the URL for accessing an object in a storage account by appending the object’s location in the storage account to the endpoint. For example, a blob address might have this format: http://mystorageaccount.blob.core.windows.net/mycontainer/myblob.

You can also configure your storage account to use a custom domain for blobs. For more information, see Configure a custom domain name for your Azure Storage account.

Control access to account data

By default, the data in your account is available only to you, the account owner. You have control over who may access your data and what permissions they have.

Every request made against your storage account must be authorized. At the level of the service, the request must include a valid Authorization header. Specifically, this header includes all of the information necessary for the service to validate the request before executing it.

You can grant access to the data in your storage account using any of the following approaches:

  • Azure Active Directory: Use Azure Active Directory (Azure AD) credentials to authenticate a user, group, or other identity for access to blob and queue data. If authentication of an identity is successful, then Azure AD returns a token to use in authorizing the request to Azure Blob storage or Queue storage. For more information, see Authenticate access to Azure Storage using Azure Active Directory.
  • Shared Key authorization: Use your storage account access key to construct a connection string that your application uses at runtime to access Azure Storage. The values in the connection string are used to construct the Authorization header that is passed to Azure Storage. For more information, see Configure Azure Storage connection strings.
  • Shared access signature: Use a shared access signature to delegate access to resources in your storage account, if you aren’t using Azure AD authorization. A shared access signature is a token that encapsulates all of the information needed to authorize a request to Azure Storage on the URL. You can specify the storage resource, the permissions granted, and the interval over which the permissions are valid as part of the shared access signature. For more information, see Using shared access signatures (SAS).

Authenticating users or applications using Azure AD credentials provides superior security and ease of use over other means of authorization. While you can continue to use Shared Key authorization with your applications, using Azure AD circumvents the need to store your account access key with your code. You can also continue to use shared access signatures (SAS) to grant fine-grained access to resources in your storage account, but Azure AD offers similar capabilities without the need to manage SAS tokens or worry about revoking a compromised SAS.

Microsoft recommends using Azure AD authorization for your Azure Storage blob and queue applications when possible.

Copying data into a storage account

Microsoft provides utilities and libraries for importing your data from on-premises storage devices or third-party cloud storage providers. Which solution you use depends on the quantity of data you’re transferring.

When you upgrade to a general-purpose v2 account from a general-purpose v1 or Blob storage account, your data is automatically migrated. Microsoft recommends this pathway for upgrading your account. However, if you decide to move data from a general-purpose v1 account to a Blob storage account, then you’ll migrate your data manually, using the tools and libraries described below.


AzCopy is a Windows command-line utility designed for high-performance copying of data to and from Azure Storage. You can use AzCopy to copy data into a Blob storage account from an existing general-purpose storage account, or to upload data from on-premises storage devices. For more information, see Transfer data with the AzCopy Command-Line Utility.

Data movement library

The Azure Storage data movement library for .NET is based on the core data movement framework that powers AzCopy. The library is designed for high-performance, reliable, and easy data transfer operations similar to AzCopy. You can use the data movement library to take advantage of AzCopy features natively. For more information, see Azure Storage Data Movement Library for .NET

REST API or client library

You can create a custom application to migrate your data from a general-purpose v1 storage account into a Blob storage account. Use one of the Azure client libraries or the Azure storage services REST API. Azure Storage provides rich client libraries for multiple languages and platforms like .NET, Java, C++, Node.JS, PHP, Ruby, and Python. The client libraries offer advanced capabilities such as retry logic, logging, and parallel uploads. You can also develop directly against the REST API, which can be called by any language that makes HTTP/HTTPS requests.

For more information about the Azure Storage REST API, see Azure Storage Services REST API Reference.

Blobs encrypted using client-side encryption store encryption-related metadata with the blob. If you copy a blob that is encrypted with client-side encryption, ensure that the copy operation preserves the blob metadata, and especially the encryption-related metadata. If you copy a blob without the encryption metadata, the blob content cannot be retrieved again. For more information regarding encryption-related metadata, see Azure Storage Client-Side Encryption.

Storage account billing

You’re billed for Azure Storage based on your storage account usage. All objects in a storage account are billed together as a group.

Storage costs are calculated according to the following factors:

  • Region refers to the geographical region in which your account is based.
  • Account type refers to the type of storage account you’re using.
  • Access tier refers to the data usage pattern you’ve specified for your general-purpose v2 or Blob storage account.
  • Storage Capacity refers to how much of your storage account allotment you’re using to store data.
  • Replication determines how many copies of your data are maintained at one time, and in what locations.
  • Transactions refer to all read and write operations to Azure Storage.
  • Data egress refers to any data transferred out of an Azure region. When the data in your storage account is accessed by an application that isn’t running in the same region, you’re charged for data egress. For information about using resource groups to group your data and services in the same region to limit egress charges, see What is an Azure resource group?.

The Azure Storage Pricing page provides detailed pricing information based on account type, storage capacity, replication, and transactions. The Data Transfers Pricing Details provides detailed pricing information for data egress. You can use the Azure Storage Pricing Calculator to help estimate your costs.

Best Binary Options Brokers: 2020 Ranking
  • Binarium

    Best Choice! The leader in our ranking!
    Perfect for beginners!
    Free Demo Acc + Free Trading Education!

  • Binomo

    Good choice for experienced traders!

Like this post? Please share to your friends:
Binary Options Trading Education
Leave a Reply

;-) :| :x :twisted: :smile: :shock: :sad: :roll: :razz: :oops: :o :mrgreen: :lol: :idea: :grin: :evil: :cry: :cool: :arrow: :???: :?: :!: